Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Time Limit Exceeded):


global N,K
global ws

def check(max_p):
    track=0
    now=0
    for i in range (N):
        if(ws[i]>max_p):return False
        if(now+ws[i]>max_p):
            track+=1
            now=ws[i]
        else:
            now+=ws[i]
    if now>0:
        track+=1
    if(track>K):
        return False
    else:
        return True

N,K=map(int,input().split())

ans=0
now=0
ws=[]
for i in range(N):
    w=int(input())
    ws.append(w)

amin=0
amax=int(1E50)

while amin+1!=amax:
    amid=(amin+amax)//2
    if(check(amid)):
        amax=amid
    else:
        amin=amid
print(amax)
   

Fixed submission:


global N,K
global ws

def check(max_p):
    track=0
    now=0
    for i in range (N):
        if(ws[i]>max_p):return False
        if(now+ws[i]>max_p):
            track+=1
            now=ws[i]
        else:
            now+=ws[i]
    if now>0:
        track+=1
    if(track>K):
        return False
    else:
        return True

N,K=map(int,input().split())

ans=0
now=0
ws=[]
for i in range(N):
    w=int(input())
    ws.append(w)

amin=0
amax=int(1E48)

while amin+1!=amax:
    amid=(amin+amax)//2
    if(check(amid)):
        amax=amid
    else:
        amin=amid
print(amax)

Buggy python submission (verdict: Time Limit Exceeded):


global N,K
global ws

def check(max_p):
    track=0
    now=0
    for i in range (N):
        if(ws[i]>max_p):return False
        if(now+ws[i]>max_p):
            track+=1
            now=ws[i]
        else:
            now+=ws[i]
    if now>0:
        track+=1
    if(track>K):
        return False
    else:
        return True

N,K=map(int,input().split())

ans=0
now=0
ws=[]
for i in range(N):
    w=int(input())
    ws.append(w)

amin=0
amax=int(1E100)

while amin+1!=amax:
    amid=(amin+amax)//2
    if(check(amid)):
        amax=amid
    else:
        amin=amid
print(amax)
   

Fixed submission:


global N,K
global ws

def check(max_p):
    track=0
    now=0
    for i in range (N):
        if(ws[i]>max_p):return False
        if(now+ws[i]>max_p):
            track+=1
            now=ws[i]
        else:
            now+=ws[i]
    if now>0:
        track+=1
    if(track>K):
        return False
    else:
        return True

N,K=map(int,input().split())

ans=0
now=0
ws=[]
for i in range(N):
    w=int(input())
    ws.append(w)

amin=0
amax=int(1E48)

while amin+1!=amax:
    amid=(amin+amax)//2
    if(check(amid)):
        amax=amid
    else:
        amin=amid
print(amax)
Buggy python submission (verdict: Runtime Error):
import math
x1,y1,x2,y2=map(int,input().split())
dx=abs(x1-x2)
dy=abs(y1-y2)
print(math.sqrt(dx*dx+dy*dy))

Fixed submission:
import math
x1,y1,x2,y2=map(float,input().split())
dx=abs(x1-x2)
dy=abs(y1-y2)
print(math.sqrt(dx*dx+dy*dy))
Buggy python submission (verdict: Time Limit Exceeded):
class Dice:
    def __init__(self):
        self.u=1
        self.w=2
        self.s=3
        self.e=4
        self.n=5
        self.d=6
        self.dic={"W":0,"S":1,"E":2,"N":3}
    
    def __init__(self,u,w,s,e,n,d):
        self.u=u
        self.w=w
        self.s=s
        self.e=e
        self.n=n
        self.d=d
        self.dic={"W":0,"S":1,"E":2,"N":3}

    def rot(self,way):
        if isinstance(way,str):
            way=self.dic[way]

        if(way==0):
            c=self.u
            self.u=self.e
            self.e=self.d
            self.d=self.w
            self.w=c
        elif way==1:
            c=self.u
            self.u=self.n
            self.n=self.d
            self.d=self.s
            self.s=c
        elif way==2:
            c=self.u
            self.u=self.w
            self.w=self.d
            self.d=self.e
            self.e=c

def mk_dice():
    u,s,e,w,n,d=map(int,input().split())
    return Dice(u,w,s,e,n,d)

import random
q=int(input())
dice_col=[]
ans=True
for j in range(q):
    dice_b=mk_dice()
    for dice in dice_col:
        for i in range (1000):
            dice.rot(random.randint(0,3))
            if(dice.u==dice_b.u and dice.d==dice_b.d and dice.w==dice_b.w and dice.s==dice_b.s and dice.e==dice_b.e and dice.n==dice_b.n):
                ans=False
    dice_col.append(dice_b)

if ans:
    print('Yes')
else:
    print('No')

Fixed submission:
class Dice:
    def __init__(self):
        self.u=1
        self.w=2
        self.s=3
        self.e=4
        self.n=5
        self.d=6
        self.dic={"W":0,"S":1,"E":2,"N":3}
     
    def __init__(self,u,w,s,e,n,d):
        self.u=u
        self.w=w
        self.s=s
        self.e=e
        self.n=n
        self.d=d
        self.dic={"W":0,"S":1,"E":2,"N":3}
 
    def rot(self,way):
        if isinstance(way,str):
            way=self.dic[way]
 
        if(way==0):
            c=self.u
            self.u=self.e
            self.e=self.d
            self.d=self.w
            self.w=c
        elif way==1:
            c=self.u
            self.u=self.n
            self.n=self.d
            self.d=self.s
            self.s=c
        elif way==2:
            c=self.u
            self.u=self.w
            self.w=self.d
            self.d=self.e
            self.e=c
    def get_nums(self):   
        return {self.u,self.w,self.s,self.e,self.n,self.w,self.d}

def mk_dice():
    u,s,e,w,n,d=map(int,input().split())
    return Dice(u,w,s,e,n,d)
 
import random
q=int(input())
dice_col=[]
ans=True
for j in range(q):
    dice_b=mk_dice()
    for dice in dice_col:
        if(dice.get_nums()==dice_b.get_nums()):
            for i in range (1000):
                dice.rot(random.randint(0,2))
                if(dice.u==dice_b.u and dice.d==dice_b.d and dice.w==dice_b.w and dice.s==dice_b.s and dice.e==dice_b.e and dice.n==dice_b.n):
                    ans=False
        if ~ans:
            break
    dice_col.append(dice_b)
 
if ans:
    print('Yes')
else:
    print('No')
Buggy python submission (verdict: Runtime Error):
a,b=map(int,input(),split())
print(a//b,a%b,a/b)

Fixed submission:
a,b=map(int,input().split())
print(a//b,a%b,"{0:10.20f}".format(a/b))
Buggy python submission (verdict: Runtime Error):
while True:
    a,b=map(int,input().split())
    if a==0 and b==0:break
    f=[[0 for i in range(a)]for j in range(b)]
    for i in range(a):
        for j in range(b):
            if i==0 or i==a-1 or j==0 or j==b-1:
                f[i][j]=1
    for i in range(a):
        for j in range(b):
            if f[i][j]==1:
                print('#')
            else :
                print('.')
        print()
    print()

Fixed submission:
while True:
    a,b=map(int,input().split())
    if a==0 and b==0:break
    f=[[0 for i in range(b)]for j in range(a)]
    for i in range(a):
        for j in range(b):
            if i==0 or i==a-1 or j==0 or j==b-1:
                f[i][j]=1
    for i in range(a):
        for j in range(b):
            if f[i][j]==1:
                print('#',end='')
            else :
                print('.',end='')
        print()
    print()
Buggy python submission (verdict: Runtime Error):
import sys
def line():return sys.stdin.readline().strip()

ops = {"+":lambda a,b:b + a,
     "-":lambda a,b:b - a,
     "*":lambda a,b:b * a,
     "/":lambda a,b:b / a}
while True:
    stack = []
    for s in line().split():
        if s in ops:
            stack.append(ops[s](stack.pop(),stack.pop()))
        else:
            stack.append(int(s))
    print(stack[0])

Fixed submission:
import sys
def line():return sys.stdin.readline().strip()

ops = {"+":lambda a,b:b + a,
     "-":lambda a,b:b - a,
     "*":lambda a,b:b * a,
     "/":lambda a,b:b / a}
while True:
    try:
        stack = []
        for s in line().split():
            if s in ops:
                stack.append(ops[s](stack.pop(),stack.pop()))
            else:
                stack.append(int(s))
        print(stack[0])
    except:
        break
Buggy python submission (verdict: Runtime Error):
import sys
def line():return sys.stdin.readline().strip()

import re

while True:
    e = re.findall(r"[0-9X]+",line())

    ans = -1
    for i in range(10):
        a,b,c = [int(_.replace("X",str(i))) for _ in e]
        if a + b == c :
            ans = i
            break

    if ans == -1:
        print("NA")
    else:
        print(ans)

Fixed submission:
import sys
import re
def line():return sys.stdin.readline().strip()

while True:
    try:
        e = re.findall(r"[0-9X]+",line())

        ans = -1
        for i in range(10):
            a,b,c = [_.replace("X",str(i)) for _ in e]
            if i == 0 \
                and (\
                (a[0] == "0" and len(a) != 1)\
                or (b[0] == "0" and len(b) != 1)\
                or (c[0] == "0" and len(c) != 1)\
                ):
                continue 
            if int(a) + int(b) == int(c) :
                ans = i
                break

        if ans == -1:
            print("NA")
        else:
            print(ans)
    except:
        break

Buggy python submission (verdict: Runtime Error):
import sys
import re
def line():return sys.stdin.readline().strip()

while True:

    e = re.findall(r"[0-9X]+",line())

    ans = -1
    for i in range(10):
        a,b,c = [int(_.replace("X",str(i))) for _ in e]
        if a + b == c :
            ans = i
            break

    if ans == -1:
        print("NA")
    else:
        print(ans)

Fixed submission:
import sys
import re
def line():return sys.stdin.readline().strip()

while True:
    try:
        e = re.findall(r"[0-9X]+",line())

        ans = -1
        for i in range(10):
            a,b,c = [_.replace("X",str(i)) for _ in e]
            if i == 0 \
                and (\
                (a[0] == "0" and len(a) != 1)\
                or (b[0] == "0" and len(b) != 1)\
                or (c[0] == "0" and len(c) != 1)\
                ):
                continue 
            if int(a) + int(b) == int(c) :
                ans = i
                break

        if ans == -1:
            print("NA")
        else:
            print(ans)
    except:
        break
Buggy python submission (verdict: Runtime Error):
import sys
def line():return sys.stdin.readline().strip()
def cin():return sys.stdin.readline().strip().split()
while True:
    N,M = [int(i) for i in cin()]
    if N == 0:break
    X = [int(line()) for _ in range(N)]
    c = 1
    for i in range(M):
        c+=int(line())
        if c < N and X[c - 1] != 0:
            c+=X[c - 1]
        if c >= N:
            print(i + 1)
            break

Fixed submission:
import sys
def line():return sys.stdin.readline().strip()
def cin():return sys.stdin.readline().strip().split()
while True:
    N,M = [int(i) for i in cin()]
    if N == 0:break
    X = [int(line()) for _ in range(N)]
    Y = [int(line()) for _ in range(M)]
    c = 1
    for i in range(M):
        c+=int(Y[i])
        if c < N and X[c - 1] != 0:
            c+=X[c - 1]
        if c >= N:
            print(i + 1)
            break
Buggy python submission (verdict: Runtime Error):
for i in range(1,9):
    for j in range(1,9):
        print "%d x %d = %d" % (i,j,i*j))

Fixed submission:
for i in range(1,10):
    for j in range(1,10):
        print "%dx%d=%d" % (i,j,(i*j))
Buggy python submission (verdict: Runtime Error):
def check(List):
    List.sort()
    List.revers()
    if List[0]^2 == List[1]^2+List[2]^2:
        return True
    else:
        return False

while True:
    N = input()
    
    for i in range(N):
        list = []
        for j in range(3):
            list.append(input())
        
        print check(list)
        

Fixed submission:
def check(List):
    List.sort()
    List.reverse()
    if List[0]**2 == List[1]**2+List[2]**2:
        return "YES"
    else:
        return "NO"

N = input()
    
for i in range(N):
    list = map(int, raw_input().split())
    print check(list)
Buggy python submission (verdict: Runtime Error):
x = input()
print(x**3)

Fixed submission:
x = input()
y = int(x)
print(y**3)

Buggy python submission (verdict: Runtime Error):
x = int(raw_input())
print(x**3)

Fixed submission:
x = input()
y = int(x)
print(y**3)
Buggy python submission (verdict: Runtime Error):
__author__ = 'CIPHER'
_project_ = 'PythonLehr'

class BoundingBox:
    def __init__(self, width, height):
        self.width = width;
        self.height = height;

    def CalculateBox(self, x, y, r):
        if x>= r and x<=(self.width-r) and y>=r and y<=(self.height-r):
            print("Yes")
        else:
            print("No")

width = int(input())
height = int(input())
x = int(input())
y = int(input())
r = int(input())

Box = BoundingBox(width, height)
Box.CalculateBox(x, y, r)

Fixed submission:
__author__ = 'CIPHER'
_project_ = 'PythonLehr'

class BoundingBox:
    def __init__(self, width, height):
        self.width = width;
        self.height = height;

    def CalculateBox(self, x, y, r):
        if x>= r and x<=(self.width-r) and y>=r and y<=(self.height-r):
            print("Yes")
        else:
            print("No")
'''
width = int(input("Width of the Box: "))
height = int(input("Height of the Box: "))
x = int(input("location of x: "))
y = int(input("location of y: "))
r = int(input("radius of the circle; "))
'''

# alternative input
inputList = input()
inputList = inputList.split(' ')
inputList = [int(x) for x in inputList]
# print(inputList)
width = inputList[0]
height = inputList[1]
x = inputList[2]
y = inputList[3]
r = inputList[4]

Box = BoundingBox(width, height)
Box.CalculateBox(x, y, r)
Buggy python submission (verdict: Runtime Error):

n = int(input())
for i in range(n):
    x = int(input())
    y = int(input())
    ans = x + y
    if len(str(ans)) > 80 :
        print 'overflow'
    else:
        print ans

Fixed submission:

#
n = int(raw_input())
for i in xrange(n):
    x = int(raw_input())
    y = int(raw_input())
    ans = x + y
    if len(str(ans)) > 80 :
        print 'overflow'
    else:
        print ans
Buggy python submission (verdict: Runtime Error):
a = int(input())
b = int(input())
print(a + b)


Fixed submission:
print(sum(map(int, input().split())))
Buggy python submission (verdict: Runtime Error):
time = int(input())
h = time/3600
time%3600
m = time/60
s = time%60
print("%d:%d:time = int(input())
h = time/3600
time%=3600
m = time/60
s = time%60
print("%d:%d:%d"%(h,m,s))%d"%(h,m,s))

Fixed submission:
time = int(input())
h = str(time // 3600)
m = str((time % 3600)//60)
s = str(time%60)
print(h+":"+m+":"+s)
Buggy python submission (verdict: Time Limit Exceeded):
num_of_S = int(input())
S = list(map(int, input().split(' ')))
num_of_T = int(input())
T = list(map(int, input().split(' ')))

count = 0
for s in S:
    for i in range(len(T)):
        if s == T[i]:
            count += 1
            T[i] = -1
            break

print(count)

Fixed submission:
# http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_4_B&lang=jp
sample_input = list(range(3))
sample_input[0] = '''5
1 2 3 4 5
3
3 4 1'''
sample_input[1] = '''3
1 2 3
1
5'''
sample_input[2] = ''''''
give_sample_input = None
if give_sample_input is not None:
    sample_input_list = sample_input[give_sample_input].split('\n')
    def input():
        return sample_input_list.pop(0)
        
# main
num_of_S = int(input())
S = list(map(int, input().split(' ')))
num_of_T = int(input())
T = list(map(int, input().split(' ')))

def binary_search(increasing_list, elem):
    index_min = 0
    index_max = num_of_S-1
    
    while index_max - index_min >= 2:
        index_middle = int((index_min + index_max) / 2)
        if increasing_list[index_middle] == elem:
            return True
        elif increasing_list[index_middle] > elem:
            index_max = index_middle
        else:
            index_min = index_middle
            
    if increasing_list[index_min] == elem:
        return True
    elif increasing_list[index_max] == elem:
        return True
    else:
        return False

count = 0
for t in T:
    if binary_search(S, t):
        count += 1
print(count)
Buggy python submission (verdict: Runtime Error):
# -*- coding: utf-8 -*
import math
r = int(input())
print('%.6f %.6f' % (r*r*math.pi, 2*r*math.pi))

Fixed submission:
# -*- coding: utf-8 -*
import math
r = float(input())
print('%.6f %.6f' % (r*r*math.pi, 2*r*math.pi))
Buggy python submission (verdict: Runtime Error):
a = input()
print(a**3)

Fixed submission:
x=int(input())
print(x**3)
Buggy python submission (verdict: Runtime Error):
n = int(input())
g = [[0] * n for _ in range(n)]

while n:
    l = list(map(int, input().split()))
    column_g = g[l[0] - 1]
    for i in l[2:]:
        column_g[i-1] = 1
    n -= 1
for v in column_g:
    print(*v)

Fixed submission:
n = int(input())
g = [[0] * n for _ in range(n)]

while n:
    l = list(map(int, input().split()))
    column_g = g[l[0] - 1]
    for i in l[2:]:
        column_g[i-1] = 1
    n -= 1
for v in g:
    print(*v)
Buggy python submission (verdict: Time Limit Exceeded):
M = (int)(1e9 + 7)
m, n = map(int, input().split())
ans = 1;

for i in range(n):
    ans *= m
    ans %= M

print(ans)

Fixed submission:
mod = 1000000007
m, n = map(int, input().split())
print(pow(m,n,mod))
Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
a = [int(i) for i in input().split()]

def lcm(x, y):
    if x > y:
        big = x
    else:
        big = y

    while(True):
        if((big % x == 0) and (big % y == 0)):
            lcm = big
            break
        big += 1
    return lcm

ans = a[0]
for i in a:
    ans = lcm(ans, i)
    
print(ans)

Fixed submission:
n = int(input())
a = [int(i) for i in input().split()]

def gcd(x, y):
    while(y):
        x, y = y, x%y
    return x

def lcm(x, y):
    lcm = (x*y)//gcd(x,y)
    return lcm

ans = 1
for i in a:
    ans = lcm(ans, i)
    
print(ans)

Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
a = [int(i) for i in input().split()]

def lcm(x, y):
    if x > y:
        big = x
    else:
        big = y

    while(True):
        if((big % x == 0) and (big % y == 0)):
            lcm = big
            break
        big += 1
    return lcm

ans = max(a)
for i in a:
    ans = lcm(ans, i)
    
print(ans)

Fixed submission:
n = int(input())
a = [int(i) for i in input().split()]

def gcd(x, y):
    while(y):
        x, y = y, x%y
    return x

def lcm(x, y):
    lcm = (x*y)//gcd(x,y)
    return lcm

ans = 1
for i in a:
    ans = lcm(ans, i)
    
print(ans)
Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
ans = n

i = 2
while i <= n:
    if n%i == 0:
        ans = ans//i*(i-1)
        while n%i == 0:
            n //= i
    i+=1

print(ans)

Fixed submission:
n = int(input())
ans = n

i = 2
while i*i <= n:
    if n%i == 0:
        ans = ans//i*(i-1)
        while n%i == 0:
            n //= i
    i+=1
if n != 1:
    ans = ans//n*(n-1)

print(ans)
Buggy python submission (verdict: Runtime Error):
x = raw_input()
print x ** 3

Fixed submission:
x = int(raw_input())
print x ** 3

Buggy python submission (verdict: Runtime Error):
x = raw_input()
print x ** 3

Fixed submission:
x = int(raw_input())
print x ** 3
Buggy python submission (verdict: Runtime Error):
input = raw_input().split()
print input[0] * input[1], 2 * (input[0] + input[1])

Fixed submission:
length = raw_input().split(" ")
length[0] = int(length[0])
length[1] = int(length[1])
print length[0] * length[1], 2 * (length[0] + length[1])

Buggy python submission (verdict: Runtime Error):
length = raw_input().split()
print length[0] * length[1], 2 * (length[0] + length[1])

Fixed submission:
length = raw_input().split(" ")
length[0] = int(length[0])
length[1] = int(length[1])
print length[0] * length[1], 2 * (length[0] + length[1])

Buggy python submission (verdict: Runtime Error):
length = raw_input().split(" ")
print length[0] * length[1], 2 * (length[0] + length[1])

Fixed submission:
length = raw_input().split(" ")
length[0] = int(length[0])
length[1] = int(length[1])
print length[0] * length[1], 2 * (length[0] + length[1])
Buggy python submission (verdict: Runtime Error):
for n in map(int, raw_input().split()).sort:
    print n,

Fixed submission:
numbers = map(int, raw_input().split())
numbers.sort()
for n in numbers:
    print n,

Buggy python submission (verdict: Runtime Error):
for n in map(int, raw_input().split()).sort():
    print n,

Fixed submission:
numbers = map(int, raw_input().split())
numbers.sort()
for n in numbers:
    print n,
Buggy python submission (verdict: Runtime Error):
while True:
    num = int(raw_input())
    if num == 0:
        break
    else:
        numbers.append(num)

for case, num in enumerate(numbers):
    print "Case %s: %s" %(case + 1, num)

Fixed submission:
numbers = []

while True:
    num = int(raw_input())
    if num == 0:
        break
    else:
        numbers.append(num)

for case, num in enumerate(numbers):
    print "Case %s: %s" %(case + 1, num)
Buggy python submission (verdict: Runtime Error):
n,m,r=map(int,input().split());
a=n+r-n*m-1,b=r-n*m;
s=1;
if a<b||a<0||b<0:s=0;
else:
    if b>a-b:b=a-b;
	for i in range(b):s=s*(a-i)/(i+1);
print(s)


Fixed submission:
n,m,r=map(int,input().split());
a=n+r-n*m-1;b=r-n*m;
s=1;
if a<b or a<0 or b<0:s=0;
else:
    if b>a-b:b=a-b;
    for i in range(b):s=s*(a-i)//(i+1);
print(s)

Buggy python submission (verdict: Runtime Error):
n,m,r=map(int,input().split());
a=n+r-n*m-1;b=r-n*m;
s=1;
if a<b||a<0||b<0:s=0;
else:
    if b>a-b:b=a-b;
	for i in range(b):s=s*(a-i)/(i+1);
print(s)


Fixed submission:
n,m,r=map(int,input().split());
a=n+r-n*m-1;b=r-n*m;
s=1;
if a<b or a<0 or b<0:s=0;
else:
    if b>a-b:b=a-b;
    for i in range(b):s=s*(a-i)//(i+1);
print(s)

Buggy python submission (verdict: Runtime Error):
n,m,r=map(int,input().split());
a=n+r-n*m-1;b=r-n*m;
s=1;
if a<b or a<0 or b<0:s=0;
else:
    if b>a-b:b=a-b;
	for i in range(b):s=s*(a-i)/(i+1);
print(s)


Fixed submission:
n,m,r=map(int,input().split());
a=n+r-n*m-1;b=r-n*m;
s=1;
if a<b or a<0 or b<0:s=0;
else:
    if b>a-b:b=a-b;
    for i in range(b):s=s*(a-i)//(i+1);
print(s)
Buggy python submission (verdict: Runtime Error):
for(a in range(1,9)):
	for(b in range(1,9)):
		print(a,"x",b,"=",a*b)


Fixed submission:
for a in range(1,10):
	for b in range(1,10):
		print(a,"x",b,"=",a*b,sep="")
Buggy python submission (verdict: Runtime Error):
n = int(input())
for i in range(n):
	s = int(input())+int(input())
	if len(str(s))>=80:
		print("overflow")
	else
		print(a+b)

Fixed submission:
n = int(input())
for i in range(n):
	s = int(input())+int(input())
	if len(str(s))>80:
		print("overflow")
	else:
		print(s)
Buggy python submission (verdict: Runtime Error):
inputs = [flaot(i) for i in input()]

print(max(inputs) - min(inputs))

Fixed submission:
def get_input():
    while True:
        try:
            yield input()
        except EOFError:
            break

inputs = [float(i) for i in get_input()]

print(max(inputs) - min(inputs))

Buggy python submission (verdict: Runtime Error):
inputs = [float(i) for i in input()]

print(max(inputs) - min(inputs))

Fixed submission:
def get_input():
    while True:
        try:
            yield input()
        except EOFError:
            break

inputs = [float(i) for i in get_input()]

print(max(inputs) - min(inputs))
Buggy python submission (verdict: Runtime Error):
import math
n = map(int, raw_input().split())
print math.hypot((n[0] - n[2]), (n[1] - n[3]))

Fixed submission:
import math
n = map(float, raw_input().split())
print math.hypot((n[0] - n[2]), (n[1] - n[3]))