ZhenlongDai/ACPR huggingface dataset:
Problem: p03346
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

N = int(input())

Q = [0]*N
for i in range(N):
    p = int(input())
    Q[p-1] = i

cnt = 1
now_idx = -1
ans = 0
for i in range(N):
    idx = Q[i]
    if idx>now_idx:
        cnt += 1
        ans = max(ans, cnt)
    else:
        cnt = 1
    now_idx = idx
print(N-ans)
    

Failing test case input:
4
1
4
2
3

Expected output:
1


Actual output:
0


Fixed submission (verdict: Accepted):
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

N = int(input())

Q = [0]*N
for i in range(N):
    p = int(input())
    Q[p-1] = i

cnt = 0
now_idx = -1
ans = 0
for i in range(N):
    idx = Q[i]
    if idx>now_idx:
        cnt += 1
        ans = max(ans, cnt)
    else:
        cnt = 1
    now_idx = idx

print(N-ans)

Problem: p03346
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def main():
    N=int(input())
    P=[0]*N
    p=[False]*(N+1)
    P[0]=int(input())
    for i in range(1,N):
        P[i]=int(input())
        if P[i]-1 in P[:i-1]:
            p[P[i]-1] = True
    ans=0
    j=0
    for i in range(N):
        if p[i]==True:
            j+=1
        else:
            ans=max(ans,j)
            j=0
    ans=max(ans,j)
    print(N-ans-1)


if __name__ == "__main__":
    main()


Failing test case input:
6
2
3
5
1
4
6

Expected output:
3


Actual output:
4


Fixed submission (verdict: Accepted):
def main():
    N=int(input())
    p=[False]*(N+1)
    c=[False]*(N+1)
    for i in range(N):
        x=int(input())
        c[x]=True
        if c[x-1]:
            p[x-1] = True
    ans=0
    j=0
    for i in range(1,N+1):
        if p[i]:
            j+=1
        else:
            ans=max(ans,j)
            j=0
    ans=max(ans,j)
    print(N-ans-1)

if __name__ == "__main__":
    main()

Problem: p03346
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
P = [int(input()) for _ in range(N)]
index = [-1] * N
for i, p in enumerate(P):
    index[p-1] = i
res = 1
for i in range(N-1):
    if index[i] < index[i+1]:
        res += 1
    else:
        res = 1
ans = N-res
print(ans)

Failing test case input:
8
6
3
1
2
5
4
8
7

Expected output:
6


Actual output:
7


Fixed submission (verdict: Accepted):
N = int(input())
P = [int(input()) for _ in range(N)]
index = [-1] * N
for i, p in enumerate(P):
    index[p-1] = i
res = 1
tmp = 1
for i in range(N-1):
    if index[i] < index[i+1]:
        tmp += 1
        res = max(res, tmp)
    else:
        tmp = 1
ans = N-res
print(ans)
Problem: p03346
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def main():

    N = int(input())
    p = []
    for _ in range(N): p.append(int(input()))

    d = dict()
    for i in range(N):
        if i == 1:
            d[p[i]] = 1
        else:
            if p[i] - 1 in d:
                d[p[i]] = d[p[i]-1] + 1
            else:
                d[p[i]] = 1
    return N - max(list(d.values()))


if __name__ == '__main__':
    print(main())


Failing test case input:
6
2
3
5
1
4
6

Expected output:
3


Actual output:
4


Fixed submission (verdict: Accepted):
def main():

    N = int(input())
    p = []
    for _ in range(N): p.append(int(input()))

    d = dict()
    for i in range(N):
        if i == 0:
            d[p[i]] = 1
        else:
            if p[i] - 1 in d:
                d[p[i]] = d[p[i]-1] + 1
            else:
                d[p[i]] = 1
    return N - max(list(d.values()))


if __name__ == '__main__':
    print(main())

Problem: p03346
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def main():
    N = int(input())
    P = [0 for _ in range(N)]
    for i in range(N):
        P[i] = int(input())
    count = [0 for _ in range(N)]
    C = 0
    for i in range(N):
        count[i] = (P[i]-1) - i
        if count[i] > 0:
            C+=count[i]
    return C

if __name__ == '__main__':
    print(main())

Failing test case input:
8
6
3
2
1
7
4
8
5

Expected output:
5


Actual output:
9


Fixed submission (verdict: Accepted):
def main():
    N = int(input())
    P = [0 for _ in range(N)]
    for i in range(N):
        P[i] = int(input())
    C = [1,1]
    Q = [0 for _ in range(N)]
    for i in range(N):
        Q[P[i]-1] = i
    for i in range(1,N):
        if Q[i-1]<Q[i]:
            C[0]+=1
            C[1] = max(C[1], C[0])
        else:
            C[0] = 1
    print(N-C[1])

if __name__ == '__main__':
    main()

Problem: p03346
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n=int(input())
a=[]
for i in range(n):
  x=int(input())
  a.append(x)
d={}
f=0
maxi=0
for i in range(n):
  if((a[i]-1) in d):
    d[a[i]]=d[a[i]-1]+1
    if(f==0):
      maxi=d[a[i]]
    else:
      if(d[a[i]]>maxi):
        maxi=d[a[i]]
  else:
    d[a[i]]=0
print(n-maxi-1)



Failing test case input:
6
2
3
5
1
4
6

Expected output:
3


Actual output:
4


Fixed submission (verdict: Accepted):
n=int(input())
a=[]
for i in range(n):
  x=int(input())
  a.append(x)
d={}
f=0
maxi=0
for i in range(n):
  if((a[i]-1) in d):
    d[a[i]]=d[a[i]-1]+1
  else:
    d[a[i]]=1

for i in d:
  if(i==0):
    maxi=d[i]
  else:
    if(d[i]>maxi):
      maxi=d[i]

print(n-maxi)
Problem: p03346
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
a = [0]
for _ in range(N):
  a.append(int(input()))

Q = [0 for i in range(N + 1)]
for i in range(N + 1):
    Q[a[i]] = i
ans = 1
num = 0

for idx in range(2, len(a) - 1):
    if a[idx - 1] < a[idx]:
        num += 1
    else:
        ans, num = max(num, ans), 1

print(N - max(num, ans))

Failing test case input:
8
6
3
2
1
4
7
8
5

Expected output:
5


Actual output:
4


Fixed submission (verdict: Accepted):
N = int(input())
a = [0]
for _ in range(N):
  a.append(int(input()))

Q = [0 for i in range(N + 1)]
for i in range(N + 1):
    Q[a[i]] = i
ans = 1
num = 1

for idx in range(2, len(Q)):
    if Q[idx - 1] < Q[idx]:
        num += 1
    else:
        ans, num = max(num, ans), 1

print(N - max(num, ans))

Problem: p03346
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
a = [0 for i in range(N)]
chain = [0 for i in range(N+1)]
for i in range(N):
  a[i] = int(input())
  chain[a[i]] = chain[a[i]-1]+1
print(max(chain))

Failing test case input:
8
6
3
1
2
5
4
8
7

Expected output:
6


Actual output:
2


Fixed submission (verdict: Accepted):
N = int(input())
a = [0 for i in range(N)]
chain = [0 for i in range(N+1)]
for i in range(N):
  a[i] = int(input())
  chain[a[i]] = chain[a[i]-1]+1
print(N-max(chain))

Problem: p03346
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
dp = [0]*N
for i in range(N):
  dp[int(input())-1] = i
ans = 0
cc = 0
for i in range(N-1):
  if dp[i] < dp[i+1]:
    cc += 1
  else:
    ans = max(cc, ans)
    cc = 0
ans = max(cc, ans)
print(N-ans)


Failing test case input:
8
6
3
2
1
7
4
8
5

Expected output:
5


Actual output:
6


Fixed submission (verdict: Accepted):
N = int(input())
dp = [0]*N
for i in range(N):
  dp[int(input())-1] = i
ans = 0
cc = 0
for i in range(N-1):
  if dp[i] < dp[i+1]:
    cc += 1
  else:
    ans = max(cc, ans)
    cc = 0
ans = max(cc, ans)
print(N-ans-1)

Problem: p03346
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N=int(input())
P=[int(input())-1 for i in range(N)]
Q=[0 for i in range(N)]
for i in range(N):
    Q[P[i]]=i
L=0
R=0
for i in range(N-1):
    if Q[i]>Q[i+1]:
        R=N-i-1
        break
for i in range(N-1)[::-1]:
    if Q[i]>Q[i+1]:
        L=i+1
        break
print(min([L,R]))


Failing test case input:
8
6
5
2
1
3
4
8
7

Expected output:
5


Actual output:
7


Fixed submission (verdict: Accepted):
N=int(input())
P=[int(input())-1 for i in range(N)]
Q=[0 for i in range(N)]
for i in range(N):
    Q[P[i]]=i
L=[1]
k=0
for i in range(1,N):
    if Q[i-1]<Q[i]:
        L[k]+=1
    else:
        L.append(0)
        k+=1
        L[k]+=1
print(N-max(L))
Problem: p03346
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def main():
    N = int(input())
    P = [0 for _ in range(N)]
    for i in range(N):
        P[i] = int(input())
    count = [0 for _ in range(N)]
    C = 0
    for i in range(N):
        count[i] = (P[i]-1) - i
        if count[i] > 0:
            C+=count[i]
    return min(C, N)

if __name__ == '__main__':
    print(main())

Failing test case input:
8
6
3
1
2
5
4
8
7

Expected output:
6


Actual output:
7


Fixed submission (verdict: Accepted):
def main():
    N = int(input())
    P = [0 for _ in range(N)]
    for i in range(N):
        P[i] = int(input())
    C = [1,1]
    Q = [0 for _ in range(N)]
    for i in range(N):
        Q[P[i]-1] = i
    for i in range(1,N):
        if Q[i-1]<Q[i]:
            C[0]+=1
            C[1] = max(C[1], C[0])
        else:
            C[0] = 1
    print(N-C[1])

if __name__ == '__main__':
    main()

Problem: p03346
Buggy submission (Python (3.8.2), verdict: Wrong Answer):

n = int(input())
q = [0]*n
for i in range(n):
    p = int(input())-1
    q[p] = i
    
s=f=0
c = {1}
for i in range(2,n):
    if q[i]<q[i-1]:
        f=i-1
        c.add(f-s+1)
        s=i
print(n-max(c))

Failing test case input:
4
2
4
1
3

Expected output:
2


Actual output:
1


Fixed submission (verdict: Accepted):

n = int(input())
q = [0]*n
for i in range(n):
    p = int(input())-1
    q[p] = i
    
s=f=0
c = set()
for i in range(1,n):
    if q[i]<q[i-1]:
        f=i-1
        c.add(f-s+1)
        s=i
if c==set():
    print(0)
else:
    print(n-max(c))
Problem: p03671
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a = list(map(int, input().split()))
a.sort()
print(sum(a)-min(a))

Failing test case input:
88 8 713

Expected output:
96


Actual output:
801


Fixed submission (verdict: Accepted):
a = list(map(int, input().split()))
print(sum(a)-max(a))

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys

a, b, c = map(int, sys.stdin.readline().split())

m = max([a,b,c])

print(a + b + c - 2 * m)

Failing test case input:
01000 10111 10111

Expected output:
11111


Actual output:
1000


Fixed submission (verdict: Accepted):
import sys

a, b, c = map(int, sys.stdin.readline().split())

m = max([a,b,c])

print(a + b + c - m)

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = list(map(int, input().split()))
print(A[0] + A[1])


Failing test case input:
11000 10110 10000

Expected output:
20110


Actual output:
21110


Fixed submission (verdict: Accepted):
A = sorted(list(map(int, input().split())))
print(A[0] + A[1])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
num = input().split()
num_i = [int(s) for s in num]

a,b,c = num_i
min_a = a+b

if(min_a > b+c):
    min_a = b+c
    if(min_a > c+a):
        min_a = c+a
print(min_a)

Failing test case input:
-27 6 0

Expected output:
-27


Actual output:
-21


Fixed submission (verdict: Accepted):
num = input().split()
num_i = [int(s) for s in num]

a,b,c = num_i
min_1 = a+b
min_2 = b+c
min_3 = c+a

min_a1 = min(min_1, min_2)
min_a = min(min_a1, min_3)
print(min_a)

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c=map(int,input().split());print(max(a+b,b+c,a+c))

Failing test case input:
00100 00110 00100

Expected output:
200


Actual output:
210


Fixed submission (verdict: Accepted):
a,b,c=map(int,input().split());print(min(a+b,b+c,a+c))

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
num = list(map(int, input().split()))
a = num[0]
b = num[1]
c = num[2]

if a+b <= a+c:
	if a+b  <= b+c:
		print(a+b)
	else:
		print(b+c)
else:
	print(a+c)
	


Failing test case input:
11000 10111 10100

Expected output:
20211


Actual output:
21100


Fixed submission (verdict: Accepted):
num = list(map(int, input().split()))
a = num[0]
b = num[1]
c = num[2]

if a+b <= a+c:
	if a+b  <= b+c:
		print(a+b)
	else:
		print(b+c)
elif a+c <= b+c:
	print(a+c)
else:
	print(b+c)

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = map(int, input().split())
li = [a,b,c]
print(li[0] + li[1])


Failing test case input:
-5 4 1

Expected output:
-4


Actual output:
-1


Fixed submission (verdict: Accepted):
a, b, c = map(int, input().split())
li = [a,b,c]
li.sort()
print(li[0] + li[1])
Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def miner(a):
    
    a.sort
    ans = int(a[0]) + int(a[1])
    return ans

def main():
    a = list(map(int , input().split()))
    print(miner(a))

if __name__ == '__main__':
    main()

Failing test case input:
11000 10110 10111

Expected output:
20221


Actual output:
21110


Fixed submission (verdict: Accepted):
def miner(a):
    
    a.sort()
    ans = int(a[0]) + int(a[1])
    return ans

def main():
    a = list(map(int , input().split()))
    print(miner(a))

if __name__ == '__main__':
    main()

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):


data = input()
A = data.split(" ")
A.sort()
print(int(A[0])+int(A[1]))


Failing test case input:
167 1 33

Expected output:
34


Actual output:
168


Fixed submission (verdict: Accepted):


data = input()
A = data.split(" ")
A.sort(key = lambda x:int(x))
print(int(A[0])+int(A[1]))

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
al = list(map(int,input().split()))
print(sum(al[:2]))

Failing test case input:
11101 10110 11000

Expected output:
21110


Actual output:
21211


Fixed submission (verdict: Accepted):
al = list(map(int,input().split()))
al = sorted(al)
print(sum(al[:2]))

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=list(map(int,input().split()))
print(a[0]+a[1])

Failing test case input:
-12 4 1

Expected output:
-11


Actual output:
-8


Fixed submission (verdict: Accepted):
a=list(sorted(map(int,input().split())))
print(a[0]+a[1])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=list(map(int,input().split()))
print(a)
a.sort()
print(a[0]+a[1])

Failing test case input:
11111 01000 11011

Expected output:
12011


Actual output:
[11111, 1000, 11011]
12011


Fixed submission (verdict: Accepted):
a=list(map(int,input().split()))

a.sort()
print(a[0]+a[1])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = map(int, input().split())
print(min(a+b, b+c, b+c))

Failing test case input:
-30 0 -1

Expected output:
-31


Actual output:
-30


Fixed submission (verdict: Accepted):
a, b, c = map(int, input().split())
print(min(a+b, b+c, a+c))

Problem: p03671
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
s=list(input().split())
s.sort()
a=int(s[0])
b=int(s[1])
c=int(s[2])

print(a+b)


Failing test case input:
167 6 59

Expected output:
65


Actual output:
226


Fixed submission (verdict: Accepted):
s=list(input().split())
a=int(s[0])
b=int(s[1])
c=int(s[2])
s2=[a,b,c]
s2.sort()

print(s2[0]+s2[1])

Problem: p03671
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a = list(map(int,input().split()))
a.sort()
print(a[:2])


Failing test case input:
01000 01001 00111

Expected output:
1111


Actual output:
[111, 1000]


Fixed submission (verdict: Accepted):
a = list(map(int,input().split()))
a.sort()
print(sum(a[:2]))
Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = map(int, input().split())

print(a + b + c - min(a, b, c))


Failing test case input:
10000 10010 10011

Expected output:
20010


Actual output:
20021


Fixed submission (verdict: Accepted):
a, b, c = map(int, input().split())

print(a + b + c - max(a, b, c))

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=sorted(list(map(int,input().split())), reverse=True)
print(sum(a[:2]))


Failing test case input:
11111 01000 11011

Expected output:
12011


Actual output:
22122


Fixed submission (verdict: Accepted):
a=sorted(list(map(int,input().split())))
print(sum(a[:2]))

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x = sorted(input().split())
print(int(x[0])+int(x[1]))

Failing test case input:
88 102 734

Expected output:
190


Actual output:
836


Fixed submission (verdict: Accepted):
x = sorted(list(map(int, input().split())))
print(x[0]+x[1])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
lines = input().split()
a = int(lines[0])
b = int(lines[1])
c = int(lines[2])
sum1 = a+b
sum2 = a+c
sum3 = b+c
sum_list = [sum1, sum2,sum3]
print(max(sum_list))


Failing test case input:
11000 10100 10000

Expected output:
20100


Actual output:
21100


Fixed submission (verdict: Accepted):
lines = list(input().split())
a = int(lines[0])
b = int(lines[1])
c = int(lines[2])
sum_list = [a+b, a+c, b+c]
print(min(sum_list))

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = map(int, input().split())
s = [a, b, c]
m = min(s)
s.remove(m)
print(sum(s))


Failing test case input:
11101 00010 10110

Expected output:
10120


Actual output:
21211


Fixed submission (verdict: Accepted):
a, b, c = map(int, input().split())
s = [a, b, c]
m = max(s)
s.remove(m)
print(sum(s))

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c=[int(1) for i in input().split()]
list=[a,b,c]
list.sort()
print(list[0]+list[1])

Failing test case input:
11110 00001 10111

Expected output:
10112


Actual output:
2


Fixed submission (verdict: Accepted):
a,b,c=[int(i) for i in input().split()]
list=[a,b,c]
list.sort()
print(list[0]+list[1])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
lst = sorted(list(map(int, input().split())))
print(sum(lst[::2]))

Failing test case input:
-8 2 0

Expected output:
-8


Actual output:
-6


Fixed submission (verdict: Accepted):
lst = sorted(list(map(int, input().split())))
print(sum(lst[:2]))

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
lines = list(input().split())
print(lines)
a = int(lines[0])
b = int(lines[1])
c = int(lines[2])
sum_list = [a+b, a+c, b+c]
print(min(sum_list))

Failing test case input:
167 4 713

Expected output:
171


Actual output:
['167', '4', '713']
171


Fixed submission (verdict: Accepted):
lines = list(input().split())
a = int(lines[0])
b = int(lines[1])
c = int(lines[2])
sum_list = [a+b, a+c, b+c]
print(min(sum_list))
Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
l=list(map(int,input().split()))
d=min(l)
e=min(l)
print(d+e)


Failing test case input:
11000 10110 10111

Expected output:
20221


Actual output:
20220


Fixed submission (verdict: Accepted):
l=list(map(int,input().split()))
d=min(l)
l.remove(d)
e=min(l)
print(d+e)

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def miner(a):
    
    a.sort
    ans = int(a[-1]) + int(a[-2])
    return ans

def main():
    a = list(map(int , input().split()))
    print(miner(a))

if __name__ == '__main__':
    main()

Failing test case input:
-27 6 0

Expected output:
-27


Actual output:
6


Fixed submission (verdict: Accepted):
def miner(a):
    
    a.sort()
    ans = int(a[0]) + int(a[1])
    return ans

def main():
    a = list(map(int , input().split()))
    print(miner(a))

if __name__ == '__main__':
    main()

Problem: p03671
Buggy submission (Python (3.8.2), verdict: Wrong Answer):

p_list = list(map(int,input().split()))


p_list.sort
pare = p_list[0] + p_list[1]
print(pare)

Failing test case input:
11000 10110 10111

Expected output:
20221


Actual output:
21110


Fixed submission (verdict: Accepted):

p_list = list(map(int,input().split()))


p_list = sorted(p_list)
pare = p_list[0] + p_list[1]
print(pare)

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
price = input().split(" ")
price = sorted(price)
total = int(price[0])+int(price[1])
print(total)

Failing test case input:
167 1 33

Expected output:
34


Actual output:
168


Fixed submission (verdict: Accepted):
price = input().split(" ")
price.sort(key=int)
total = int(price[0])+int(price[1])
print(total)

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c = map(int,input().split())
print(min(min(a+b,b+c),b+c))

Failing test case input:
01000 10110 10001

Expected output:
11001


Actual output:
11110


Fixed submission (verdict: Accepted):
a,b,c = map(int,input().split())
print(min(min(a+b,b+c),c+a))

Problem: p03671
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
s=list(map(int, input().split()))
s.sort
print(s[0]+s[1])

Failing test case input:
-8 2 0

Expected output:
-8


Actual output:
-6


Fixed submission (verdict: Accepted):
s=list(map(int, input().split()))
s.sort()
print(s[0]+s[1])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
array = sorted(input().split())
print(array[0]+array[1])

Failing test case input:
167 0 59

Expected output:
59


Actual output:
0167


Fixed submission (verdict: Accepted):
array = sorted(list(map(int, input().split())))
print(array[0]+array[1])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
List = list(map(int,input().split()))
List.sort()
print(List)
print(List[0]+List[1])


Failing test case input:
10101 01010 00000

Expected output:
1010


Actual output:
[0, 1010, 10101]
1010


Fixed submission (verdict: Accepted):
List = list(map(int,input().split()))
List.sort()
print(List[0]+List[1])
Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=list(map(int,input().split()))
a.sort()
print(a)
print(a[0]+a[1])

Failing test case input:
-27 6 -1

Expected output:
-28


Actual output:
[-27, -1, 6]
-28


Fixed submission (verdict: Accepted):
a=list(map(int,input().split()))
a.sort()
print(a[0]+a[1])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = list(map(int, input().split()))
a.sort
print(a[0] + a[1])

Failing test case input:
-24 14 0

Expected output:
-24


Actual output:
-10


Fixed submission (verdict: Accepted):
a = list(map(int, input().split()))
a.sort()
print(a[0] + a[1])

Problem: p03671
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A = list(map(int, input().split()))
sorted(A)
print(A[0] + A[1])


Failing test case input:
-10 7 1

Expected output:
-9


Actual output:
-3


Fixed submission (verdict: Accepted):
A = list(map(int, input().split()))
A = sorted(A)
print(A[0] + A[1])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c=map(int,input().split());print(a+b)

Failing test case input:
11000 01110 10011

Expected output:
11121


Actual output:
12110


Fixed submission (verdict: Accepted):
a,b,c=sorted(map(int,input().split()));print(a+b)

Problem: p03671
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
lst = input().split()

for i in range(3):
   lst[i] = int(lst[i])

print(lst[0] + lst[1])

Failing test case input:
11000 01110 10011

Expected output:
11121


Actual output:
12110


Fixed submission (verdict: Accepted):
lst = input().split()

for i in range(3):
   lst[i] = int(lst[i])

lst.sort()
print(lst[0] + lst[1])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def read_int_list():
    return (int(i) for i in input().split())

a,b,c = read_int_list()
print(min(a,b) + min(a,c))

Failing test case input:
95 600 780

Expected output:
695


Actual output:
190


Fixed submission (verdict: Accepted):
def read_int_list():
    return list(map(int, input().split()))

n = read_int_list()
n.sort()
print(n[0]+n[1])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
argv=input().split()

a=int(argv[0])
b=int(argv[1])
c=int(argv[2])

r=a+b

if  a+c < r:
    r= a+b

if  b + c < r:
    r= b+c

print(r)

Failing test case input:
-10 7 0

Expected output:
-10


Actual output:
-3


Fixed submission (verdict: Accepted):
argv=input().split()

a=int(argv[0])
b=int(argv[1])
c=int(argv[2])

r=a+b

if  a+c < r:
    r= a+c

if  b + c < r:
    r= b+c

print(r)

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x,y,z=map(int,input().split())
if (x+y) <= (x+z)  and (x+y)<= (y+z):
  print(x+y)
if (x+z) <= (x+y) and (x+z) <= (y+z):
  print(x+z)
if (y+z) <= (x+y) and (y+z) <= (x+z):
  print(y+z)


Failing test case input:
10000 10000 10000

Expected output:
20000

Actual output:
20000
20000
20000


Fixed submission (verdict: Accepted):
x,y,z=map(int,input().split())
if (x+y) <= (x+z)  and (x+y)<= (y+z):
  print(x+y)
elif (x+z) <= (x+y) and (x+z) <= (y+z):
  print(x+z)
elif (y+z) <= (x+y) and (y+z) <= (x+z):
  print(y+z)
else:
  print(x+z)
Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def resolve():
    ls = []

    for s in map(int, input().split(' ')):
        ls.append(s)

    print(ls[0] + ls[1])
    pass


if __name__ == '__main__':
    resolve()


Failing test case input:
01101 01011 00111

Expected output:
1122


Actual output:
2112


Fixed submission (verdict: Accepted):
def resolve():
    ls = []

    for s in map(int, input().split(' ')):
        ls.append(s)

    ls.sort()
    print(ls[0] + ls[1])
    pass


if __name__ == '__main__':
    resolve()

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = list(map(int,input().split()))
print(sum(a)-min(a))

Failing test case input:
-5 7 0

Expected output:
-5


Actual output:
7


Fixed submission (verdict: Accepted):
a = list(map(int,input().split()))
print(sum(a)-max(a))

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=input().split();a.sort(key=int);print(a);print(int(a[0])+int(a[1]))


Failing test case input:
00100 00110 00110

Expected output:
210


Actual output:
['00100', '00110', '00110']
210


Fixed submission (verdict: Accepted):
a=input().split();a.sort(key=int);print(int(a[0])+int(a[1]))

Problem: p03671
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a=list(input().split())
a.sort()
print(int(a[0])+int(a[1]))

Failing test case input:
88 652 734

Expected output:
740


Actual output:
1386


Fixed submission (verdict: Accepted):
a=list(map(int,input().split()))
a.sort()
print(a[0]+a[1])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = map( int, input().split() )

x = max(a,b,c)
if a == x:
  print(b+c)
elif b == x:
  print(a+c)
else:
  print(a+c)

Failing test case input:
88 652 734

Expected output:
740


Actual output:
822


Fixed submission (verdict: Accepted):
a, b, c = map( int, input().split() )

x = max(a,b,c)
if a == x:
  print(b+c)
elif b == x:
  print(a+c)
else:
  print(a+b)

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c = map(int, input().split())

a_b = a+b
a_c = a+c
b_c = b+c

print(max(a_b,a_c,b_c))


Failing test case input:
00010 01110 10000

Expected output:
1120


Actual output:
11110


Fixed submission (verdict: Accepted):
a,b,c = map(int, input().split())

a_b = a+b
a_c = a+c
b_c = b+c

print(min(a_b,a_c,b_c))

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c = map(int,input().split())
list = []
list.append(a)
list.append(b)
list.append(c)
print(list)
list.sort()
print(list[0]+list[1])


Failing test case input:
11111 01000 11011

Expected output:
12011


Actual output:
[11111, 1000, 11011]
12011


Fixed submission (verdict: Accepted):
a,b,c = map(int,input().split())
list = []
list.append(a)
list.append(b)
list.append(c)
list.sort()
print(list[0]+list[1])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
print(sum(sorted(list(map(int,input().split())), reverse = True)[:2]))

Failing test case input:
-12 10 0

Expected output:
-12


Actual output:
10


Fixed submission (verdict: Accepted):
print(sum(sorted(list(map(int,input().split())))[:2]))
Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c=map(int,input().split())
n=[a+b,a+c,b+c]
n.sort()
print(n[-1])

Failing test case input:
11000 00110 10011

Expected output:
10121


Actual output:
21011


Fixed submission (verdict: Accepted):
a,b,c=map(int,input().split())
n=[a+b,a+c,b+c]
n.sort()
print(n[0])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
List = list(map(int,input().split()))
List.sort
print(List[0]+List[1])


Failing test case input:
-8 2 0

Expected output:
-8


Actual output:
-6


Fixed submission (verdict: Accepted):
List = list(map(int,input().split()))
List.sort()
print(List[0]+List[1])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = input().split()

a = int(A[0])
b = int(A[1])
c = int(A[2])

minsum=a+b

if a+c < minsum:
    minsum = a+c
elif b+c < minsum:
    minsum = b+c

print(minsum)


Failing test case input:
11000 10111 10000

Expected output:
20111


Actual output:
21000


Fixed submission (verdict: Accepted):
A = input().split()

a = int(A[0])
b = int(A[1])
c = int(A[2])

minsum=a+b

if a+c < minsum:
    minsum = a+c
if b+c < minsum:
    minsum = b+c

print(minsum)

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=input().split();a.sort;print(int(a[0])+int(a[1]))


Failing test case input:
-8 2 0

Expected output:
-8


Actual output:
-6


Fixed submission (verdict: Accepted):
a=input().split();a.sort(key=int);print(int(a[0])+int(a[1]))

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
bell=list(map(int,input().split()))

bell=sorted(bell,reverse=True)

print(bell)

print(bell[1]+bell[2])



Failing test case input:
167 2 59

Expected output:
61


Actual output:
[167, 59, 2]
61


Fixed submission (verdict: Accepted):
bell=list(map(int,input().split()))

bell=sorted(bell,reverse=True)

print(bell[1]+bell[2])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = map(int, input().split())

min = a + b

if min > (a + c):
    min = a + c
elif min > (b + c):
    min = b + c
else:
    min = a + b

print(min)


Failing test case input:
11000 10111 10100

Expected output:
20211


Actual output:
21100


Fixed submission (verdict: Accepted):
a, b, c = map(int, input().split())

l = [a + b, a + c, b + c]

min = l[0]

for i in l:
    if min > i:
        min = i

print(min)

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = map(int,input().split())

s = a + b
t = a + c
u = b + c

if s >= t and s >= u:
    print(s)
elif t >= s and t >= u:
    print(t)
else:
    print(u)

Failing test case input:
01000 00110 10011

Expected output:
1110


Actual output:
11011


Fixed submission (verdict: Accepted):
a, b, c = map(int,input().split())

s = a + b
t = a + c
u = b + c

if s <= t and s <= u:
    print(s)
elif t <= s and t <= u:
    print(t)
else:
    print(u)
Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s=input().split()

s.sort()

print(int(s[0])+int(s[1]))

Failing test case input:
88 96 426

Expected output:
184


Actual output:
514


Fixed submission (verdict: Accepted):
s=list(map(int,input().split()))
 
s.sort()
 
print(s[0]+s[1])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c=input().split()
list=[a,b,c]
sorted(list)
print(int(list[0])+int(list[1]))

Failing test case input:
11010 01001 10011

Expected output:
11012


Actual output:
12011


Fixed submission (verdict: Accepted):
a,b,c=input().split()
list=[a,b,c]
list.sort(key=int)
print(int(list[0])+int(list[1]))

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
(a, b, c) = map(int, input().split())

ans = a+b+c - min(a,b,c)
print(ans)

Failing test case input:
00100 00110 00110

Expected output:
210


Actual output:
220


Fixed submission (verdict: Accepted):
(a, b, c) = map(int, input().split())

ans = a+b+c - max(a,b,c)
print(ans)

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = [int(x) for x in input().split()]
s = 0
if a[0] <= a[1]:
    s = a[0]
    if a[1] <= a[2]:
        s += a[1]
    else:
        s += a[2]
else:
    s = a[1]
    if a[0] <= a[2]:
        s += a[0]
    else:
        s += a[1]
print(s)


Failing test case input:
167 0 33

Expected output:
33


Actual output:
0


Fixed submission (verdict: Accepted):
a = [int(x) for x in input().split()]
s = 0
if a[0] <= a[1]:
    s = a[0]
    if a[1] <= a[2]:
        s += a[1]
    else:
        s += a[2]
else:
    s = a[1]
    if a[0] <= a[2]:
        s += a[0]
    else:
        s += a[2]
print(s)

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = map(int,input().split())

s = a + b
t = a + c
u = b + c

if s > t and s > u:
    print(s)
elif t > s and t > u:
    print(t)
else:
    print(u)

Failing test case input:
01000 00110 10011

Expected output:
1110


Actual output:
11011


Fixed submission (verdict: Accepted):
a, b, c = map(int,input().split())

s = a + b
t = a + c
u = b + c

if s <= t and s <= u:
    print(s)
elif t <= s and t <= u:
    print(t)
else:
    print(u)

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
print(sum(sorted(list(map(int, input().split())))[::-1][0:2]))

Failing test case input:
11101 10110 11000

Expected output:
21110


Actual output:
22101


Fixed submission (verdict: Accepted):
print(sum(sorted(map(int, input().split()))[:2]))

Problem: p03671
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b,c=input().split()
a=int(a)
b=int(b)
c=int(c)
ls=[a,b,c]
ls.sort()
print(a+b)

Failing test case input:
11000 01110 10011

Expected output:
11121


Actual output:
12110


Fixed submission (verdict: Accepted):
a,b,c=input().split()
a=int(a)
b=int(b)
c=int(c)
ls=[a,b,c]
ls.sort()
print(ls[0]+ls[1])
Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
number = list(map(int,input().split()))

min = min(number)

number.remove(min)

print(number[0] + number[1])

Failing test case input:
-10 7 0

Expected output:
-10


Actual output:
7


Fixed submission (verdict: Accepted):
number = list(map(int,input().split()))

max = max(number)

number.remove(max)

print(number[0] + number[1])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
l = list(map(int,input().split()))
print(sum(l)-2*max(l))

Failing test case input:
11111 01000 11010

Expected output:
12010


Actual output:
899


Fixed submission (verdict: Accepted):
l = list(map(int,input().split()))
print(sum(l)-max(l))

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = map(int, input().split())
print(max(a+b, b+c, c+a))

Failing test case input:
55 600 780

Expected output:
655


Actual output:
1380


Fixed submission (verdict: Accepted):
a, b, c = map(int, input().split())
print(min(a+b, b+c, c+a))

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = list(sorted(list(map(int,input().split()))))
print(a[-1] + a[-2])

Failing test case input:
11101 00111 11100

Expected output:
11211


Actual output:
22201


Fixed submission (verdict: Accepted):
a = list(sorted(list(map(int,input().split()))))
print(a[0] + a[-2])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = map(int, input().split())
p = []
p.append(a+b)
p.append(b+c)
p.append(c+a)
p.sort()
print(p[0] + p[1])


Failing test case input:
700 600 780

Expected output:
1300

Actual output:
2680


Fixed submission (verdict: Accepted):
a, b, c = map(int, input().split())
p = []
p.append(a+b)
p.append(b+c)
p.append(c+a)
p.sort()
print(p[0])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = list(map(int, input().split()))
sorted(a)
print(a[0] + a[1])

Failing test case input:
11010 01001 10011

Expected output:
11012


Actual output:
12011


Fixed submission (verdict: Accepted):
a = list(map(int, input().split()))
a.sort()
print(a[0] + a[1])

Problem: p03671
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a, b, c = map(int, input().split())
print(max(a * b, a * c, c * b))

Failing test case input:
11000 10110 10000

Expected output:
20110


Actual output:
111210000


Fixed submission (verdict: Accepted):
a, b, c = map(int, input().split())
print(min(a + b, a + c, c + b))

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c=map(int,input().split())
print(min(a+b,a+b,b+c))

Failing test case input:
-15 6 0

Expected output:
-15


Actual output:
-9


Fixed submission (verdict: Accepted):
a,b,c=map(int,input().split())
print(min(a+b,a+c,b+c))

Problem: p03671
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a, b, c = map(int, input().split())

print(min(a + b, a + c, a + c))


Failing test case input:
11111 00100 11000

Expected output:
11100


Actual output:
11211


Fixed submission (verdict: Accepted):
a, b, c = map(int, input().split())

print(min(a + b, b + c, a + c))
Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = map(int, input().split())
print(sum(sorted([a, b, c])[:1]))

Failing test case input:
95 652 780

Expected output:
747


Actual output:
95


Fixed submission (verdict: Accepted):
a, b, c = map(int, input().split())
print(a + b + c - max([a, b, c]))

Problem: p03671
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a, b, c = map(int, input().split())
print(a + b if a + b < b + c or a + b < c + a else (b + c if b + c < c + a else c + a))


Failing test case input:
167 1 66

Expected output:
67


Actual output:
168


Fixed submission (verdict: Accepted):
a, b, c = map(int, input().split())
print(a + b if a + b < b + c and a + b < c + a else (b + c if b + c < c + a else c + a))

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
num = list(map(int, input().split()))
a = num[0]
b = num[1]
c = num[2]

if a+b < a+c:
	if a+b  < b+c:
		print(a+b)
	else:
		print(b+c)
else:
	print(a+c)
	


Failing test case input:
11000 10111 10101

Expected output:
20212


Actual output:
21101


Fixed submission (verdict: Accepted):
num = list(map(int, input().split()))
a = num[0]
b = num[1]
c = num[2]

if a+b <= a+c:
	if a+b  <= b+c:
		print(a+b)
	else:
		print(b+c)
elif a+c <= b+c:
	print(a+c)
else:
	print(b+c)

Problem: p03671
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a_L = list(map(int,input().split()))
a_L = sorted(a_L)
print(sum(a_L[0:1]))


Failing test case input:
-4 1 6

Expected output:
-3


Actual output:
-4


Fixed submission (verdict: Accepted):
a_L = list(map(int,input().split()))
a_L = list(sorted(a_L))
print(a_L[0]+a_L[1])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
abc = input().split()
abc.sort()
print(int(abc[0]) + int(abc[1]))

Failing test case input:
95 652 780

Expected output:
747


Actual output:
1432


Fixed submission (verdict: Accepted):
abc = list(map(int, input().split()))
abc.sort()
print(abc[0] + abc[1])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = map(int, input().split())

min = a + b

if min > (a + c):
    min = a + c
elif min > (b + c):
    min = b + c

print(min)


Failing test case input:
01101 01011 00111

Expected output:
1122


Actual output:
1212


Fixed submission (verdict: Accepted):
a, b, c = map(int, input().split())

l = [a + b, a + c, b + c]

min = l[0]

for i in l:
    if min > i:
        min = i

print(min)

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
ring = list(map(int,input().split()))

ring.sort
print(ring[0] + ring[1])

Failing test case input:
11101 00010 10110

Expected output:
10120


Actual output:
11111


Fixed submission (verdict: Accepted):
ring = list(map(int,input().split()))

ring.sort()
print(ring[0] + ring[1])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
cost = list(map(int, input().split()))
cost.sort
print(cost[0]+cost[1])

Failing test case input:
167 0 33

Expected output:
33


Actual output:
167


Fixed submission (verdict: Accepted):
cost = list(map(int, input().split()))
cost.sort()
print(cost[0]+cost[1])
Problem: p03671
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
check = input().split()
check.sort()
print(int(check[0]) + int(check[1]))

Failing test case input:
167 0 59

Expected output:
59


Actual output:
167


Fixed submission (verdict: Accepted):
tmp = list(map(int,input().split()))
check = sorted(tmp)
print(int(check[0]) + int(check[1]))

Problem: p03671
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a, b, c = map(int, input().split())
print(max(a + b, a + c, c + b))

Failing test case input:
10000 00110 10011

Expected output:
10110


Actual output:
20011


Fixed submission (verdict: Accepted):
a, b, c = map(int, input().split())
print(min(a + b, a + c, c + b))

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):






x = [700, 600, 780]

y =[int(x[0]), int(x[1]), int(x[2])]

z = sorted(y)

ans = z[0] + z[1]

print(ans)


Failing test case input:
01000 01001 00111

Expected output:
1111


Actual output:
1300


Fixed submission (verdict: Accepted):





x = input().split()


y =[int(x[0]), int(x[1]), int(x[2])]

z = sorted(y)

ans = z[0] + z[1]

print(ans)

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
abc = list(map(int, input().split()))
abc.sort()
print(abc[-1]+abc[-2])

Failing test case input:
11000 01110 10011

Expected output:
11121


Actual output:
21011


Fixed submission (verdict: Accepted):
abc = list(map(int, input().split()))
abc.sort()
print(abc[0]+abc[1])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c=map(int,input().split())
L=[a,b,c]
L.sort()
print(L[1]+L[2])

Failing test case input:
-15 6 0

Expected output:
-15


Actual output:
6


Fixed submission (verdict: Accepted):
a,b,c=map(int,input().split())
L=[a,b,c]
L.sort()
print(L[1]+L[0])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c=map(int,input().split())
print(max(a+b,b+c,c+a))


Failing test case input:
2 1 73

Expected output:
3


Actual output:
75


Fixed submission (verdict: Accepted):
a,b,c=map(int,input().split())
print(min(a+b,b+c,c+a))

Problem: p03671
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a = list(map(int, input().split()))
print(sum(a)-min(a))

Failing test case input:
10000 00010 10011

Expected output:
10010


Actual output:
20011


Fixed submission (verdict: Accepted):
a = list(map(int, input().split()))
print(sum(a)-max(a))

Problem: p03671
Buggy submission (Python (3.8.2), verdict: Wrong Answer):

a = list(map(int, input().split()))
print(sum(a[0:2]))


Failing test case input:
11000 10111 10101

Expected output:
20212


Actual output:
21111


Fixed submission (verdict: Accepted):

a = sorted(list(map(int, input().split())))
print(sum(a[0:2]))

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def read_int_list():
    return list(map(int, input().split()))

n = read_int_list()
sorted(n)
print(n[0]+n[1])

Failing test case input:
-12 4 1

Expected output:
-11


Actual output:
-8


Fixed submission (verdict: Accepted):
def read_int_list():
    return list(map(int, input().split()))

n = read_int_list()
n.sort()
print(n[0]+n[1])
Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=input().split();a.sort();print(int(a[0])+int(a[1]))


Failing test case input:
167 0 59

Expected output:
59


Actual output:
167


Fixed submission (verdict: Accepted):
a=input().split();a.sort(key=int);print(int(a[0])+int(a[1]))

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
cost = list(map(int, input().split()))
cost.sort()
print(cost)
print(cost[0]+cost[1])

Failing test case input:
11111 01000 11010

Expected output:
12010


Actual output:
[1000, 11010, 11111]
12010


Fixed submission (verdict: Accepted):
cost = list(map(int, input().split()))
cost.sort()
print(cost[0]+cost[1])

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
lines = list(input().split())
print(lines)
a = int(lines[0])
b = int(lines[1])
c = int(lines[2])
sum_list = [a+b, a+c, b+c]
print(max(sum_list))

Failing test case input:
01001 00010 10011

Expected output:
1011


Actual output:
['01001', '00010', '10011']
11012


Fixed submission (verdict: Accepted):
lines = list(input().split())
a = int(lines[0])
b = int(lines[1])
c = int(lines[2])
sum_list = [a+b, a+c, b+c]
print(min(sum_list))

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
argv=input().split()

a=int(argv[0])
b=int(argv[1])
c=int(argv[2])

r=0

if a+b < a+c:
    r= a+b

if  b + c < r:
    r= b+c

print(r)

Failing test case input:
11000 10111 10000

Expected output:
20111


Actual output:
0


Fixed submission (verdict: Accepted):
argv=input().split()

a=int(argv[0])
b=int(argv[1])
c=int(argv[2])

r=a+b

if  a+c < r:
    r= a+c

if  b + c < r:
    r= b+c

print(r)

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c=map(int,input().split())
d=[a,b,c]
sum = 0

for i in range(2):
    sum += d.pop()
print(sum)

Failing test case input:
-27 6 0

Expected output:
-27


Actual output:
6


Fixed submission (verdict: Accepted):
a,b,c=map(int,input().split())
d=[a,b,c]
d.sort(reverse=True)
sum = 0

for i in range(2):
    sum += d.pop()
print(sum)

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
inp = list(input().split())
inp.sort()
print(int(inp[0]) + int(inp[1]))

Failing test case input:
167 0 59

Expected output:
59


Actual output:
167


Fixed submission (verdict: Accepted):
inp = list(map(int, input().split()))
inp.sort()
print(int(inp[0]) + int(inp[1]))

Problem: p03671
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = list(map(int,input().split()))
print(sorted(a)[-1] + sorted(a)[-2])


Failing test case input:
00010 01110 10000

Expected output:
1120


Actual output:
11110


Fixed submission (verdict: Accepted):
a = list(map(int,input().split()))
print(sorted(a)[0] + sorted(a)[1])
Problem: p03000
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,D = map(int,input().split())
X = list(map(int,input().split()))
C = [0]
q = 0
for i in range(A):
  if i == 0:
    p = X[0]
    C.append(p)
  else:
    p = p + X[i]
    C.append(p)
for i in C:
  if D <= i:
    q += 1
print(q)

Failing test case input:
3 12
16 5 1 17

Expected output:
1


Actual output:
3


Fixed submission (verdict: Accepted):
A,D = map(int,input().split())
X = list(map(int,input().split()))
C = [0]
q = 0
for i in range(A):
  if i == 0:
    p = X[0]
    C.append(p)
  else:
    p = p + X[i]
    C.append(p)
for i in C:
  if D >= i:
    q += 1

print(q)

Problem: p03000
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n,x=(int(x) for x in input().split())
list = input().split()
list.insert(0,0)
list = [int(s) for s in list]
z = 0
count = 0

for i in range(n+1):
    if z > x:
        break
    else:
        count = count + 1
        z = z + list[i]
        
count = count - 1
print(count)

Failing test case input:
0 11
51 9 1 17

Expected output:
1


Actual output:
0


Fixed submission (verdict: Accepted):
n,x=(int(x) for x in input().split())
list = input().split()
list = [int(s) for s in list]
list.append(0)
d = 0
count = 0

for i in range(n+1):
    if d > x:
        break
    else:
        count = count + 1
        d = d + list[i]

print(count)

Problem: p03000
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,X=map(int,input().split())
L = list(map(int,input().split()))
zahyo = 0
ans = 0
for i in range(len(L)):
    if X>=zahyo:
        ans += 1
        zahyo +=L[i]
    else:
        break
print(ans)      

Failing test case input:
4 9
4 0 -1 5

Expected output:
5


Actual output:
4


Fixed submission (verdict: Accepted):
N,X=map(int,input().split())
L = list(map(int,input().split()))
zahyo = 0
ans = 1
for i in range(len(L)):
    zahyo +=L[i]
    if X>=zahyo:
        ans += 1
print(ans)

Problem: p03000
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n,x=map(int,input().split())
l=list(map(int,input().split()))
ans=1
for i in l:
  if x>=i:
    ans+=1
    x-=i
  else:
    print(ans)
    exit()

Failing test case input:
4 9
4 0 -1 5

Expected output:
5


Actual output:

Fixed submission (verdict: Accepted):
n,x=map(int,input().split())
l=list(map(int,input().split()))
ans=1
for i in l:
  if x>=i:
    ans+=1
    x-=i
  else:
    break
print(ans)

Problem: p03000
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N, X = map(int, input().split())
lstL = list(map(int, input().split()))

def calcBoundCount(rangex, lstL):
    d = 0
    for i in range(0, len(lstL)):
        d = d + lstL[i]
        if rangex < d:
            return i + 1

print(calcBoundCount(X, lstL))

Failing test case input:
4 9
4 0 -1 5

Expected output:
5


Actual output:
None


Fixed submission (verdict: Accepted):
def calcBoundCount(rangex, lstL):
    d = 0
    for i in range(0, len(lstL)):
        d = d + lstL[i]
        if rangex < d:
            return i + 1
    return len(lstL) + 1
 
N, X = map(int, input().split())
lstL = list(map(int, input().split()))
 
count = calcBoundCount(X, lstL)
print((count if count <= N+1 else N+1))