ZhenlongDai/ACPR huggingface dataset:
Problem: p02684
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N, K = map(int, input().split())

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

visited = [0] * N

order = []

cur = 1
cnt = 0

while True:
    if visited[cur-1] == 0:
        visited[cur-1] += 1
        if cnt == K:
            print(cur)

    elif visited[cur-1] == 1: 
        
        order_from_cur = order[order.index(cur):]
        r = (K-cnt) % len(order_from_cur)

        final = order_from_cur[r]
        print(final)
        break
    order.append(cur)
    cur = A[cur - 1]
    cnt += 1


Failing test case input:
4 0
3 2 4 1

Expected output:
1


Actual output:
1
1


Fixed submission (verdict: Accepted):
N, K = map(int, input().split())

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

visited = [0] * N

order = []

cur = 1
cnt = 0

while True:
    if visited[cur-1] == 0:
        visited[cur-1] += 1
        if cnt == K:
            print(cur)
            break

    elif visited[cur-1] == 1: 
        
        order_from_cur = order[order.index(cur):]
        r = (K-cnt) % len(order_from_cur)

        final = order_from_cur[r]
        print(final)
        break
    order.append(cur)
    cur = A[cur - 1]
    cnt += 1
Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
A = int(input())
print((N**N)-A)

Failing test case input:
10
78

Expected output:
22


Actual output:
9999999922


Fixed submission (verdict: Accepted):
N = int(input())
A = int(input())
print((N**2)-A)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n=int(input())
a=int(input())
print(n*2-a)

Failing test case input:
10
199

Expected output:
-99


Actual output:
-179


Fixed submission (verdict: Accepted):
n=int(input())
a=int(input())
print(n**2-a)

Problem: p03597
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a = input()
n = input()
a = int(a)
n = int(n)
print (n * n - a)

Failing test case input:
10
137

Expected output:
-37


Actual output:
18759


Fixed submission (verdict: Accepted):
n = input()
a = input()
n = int(n)
a = int(a)

print (n * n - a)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
print(int(input())^2 - int(input()))

Failing test case input:
3
17

Expected output:
-8


Actual output:
-14


Fixed submission (verdict: Accepted):
print(int(input())**2 - int(input()))

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
one_side=input("一辺のマスの数:")
oneside=int(one_side)
whole=oneside**2
white_side=input("白色のマスの数:")
whiteside=int(white_side)
print(whole-whiteside)

Failing test case input:
10
95

Expected output:
5


Actual output:
一辺のマスの数:白色のマスの数:5


Fixed submission (verdict: Accepted):
one_side=input()
oneside=int(one_side)
whole=oneside**2
white_side=input()
whiteside=int(white_side)
print(whole-whiteside)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n=int(input())
a=int(input())
print(n^2 -a)

Failing test case input:
3
-58

Expected output:
67


Actual output:
63


Fixed submission (verdict: Accepted):
n=int(input())
a=int(input())
print(n**2 -a)

Problem: p03597
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n = int(input())
a = int(input())

print(n-a)

Failing test case input:
10
121

Expected output:
-21


Actual output:
-111


Fixed submission (verdict: Accepted):
n = int(input())
a = int(input())
 
print(n*n-a)

Problem: p03597
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n = int(input())
w = int(input())

print(n - w)

Failing test case input:
3
16

Expected output:
-7


Actual output:
-13


Fixed submission (verdict: Accepted):
n = int(input())
w = int(input())

print(n ** 2 - w)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
a = int(input())
print((n**n)-a)

Failing test case input:
10
61

Expected output:
39


Actual output:
9999999939


Fixed submission (verdict: Accepted):
n = int(input())
a = int(input())
print((n**2)-a)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
a = int(input())

print(n**2 - 1)

Failing test case input:
10
174

Expected output:
-74


Actual output:
99


Fixed submission (verdict: Accepted):
n = int(input())
a = int(input())
 
print(n**2 - a)
Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n=int(input())
a=int(input())

print(n*2-a)

Failing test case input:
10
199

Expected output:
-99


Actual output:
-179


Fixed submission (verdict: Accepted):
n=int(input())
a=int(input())
 
print(n**2-a)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = int(input())
b = int(input())

print(a^2 - b)

Failing test case input:
3
-22

Expected output:
31


Actual output:
27


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())

print(a*a - b)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
A = int(input())
B=N*N-A*A
print(B)

Failing test case input:
3
15

Expected output:
-6


Actual output:
-216


Fixed submission (verdict: Accepted):
N = int(input())
A = int(input())
B=N*N-A
print(B)

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

lines = sys.stdin.readlines()

N = int(lines[0])
A = int(lines[1])

print(N^2-A)

Failing test case input:
3
20

Expected output:
-11


Actual output:
-19


Fixed submission (verdict: Accepted):
import sys

lines = sys.stdin.readlines()

N = int(lines[0])
A = int(lines[1])

print(N ** 2 -A)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
A = int(input())
print(N**N-A)

Failing test case input:
3
49

Expected output:
-40


Actual output:
-22


Fixed submission (verdict: Accepted):
N = int(input())
A = int(input())
print((N**2)-A)

Problem: p03597
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a=int(input())
b=int(input())
print(a^2-b)

Failing test case input:
3
10

Expected output:
-1


Actual output:
-5


Fixed submission (verdict: Accepted):
a=int(input())
b=int(input())
print(a*a-b)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
A = int(input())

print(N * 2 - A)

Failing test case input:
3
25

Expected output:
-16


Actual output:
-19


Fixed submission (verdict: Accepted):
N = int(input())
A = int(input())
 
print(pow(N, 2) - A)

Problem: p03597
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a = int(input())
b = int(input())
print(a**a - b)

Failing test case input:
3
13

Expected output:
-4


Actual output:
14


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())
print(a**2 - b)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N=int(input())
A=int(input())
print(N**-A)

Failing test case input:
10
61

Expected output:
39


Actual output:
1e-61


Fixed submission (verdict: Accepted):
N=int(input())
A=int(input())
B=N**2-A
print(B)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
A = int(input())
result = N - A
print(str(result))

Failing test case input:
3
22

Expected output:
-13


Actual output:
-19


Fixed submission (verdict: Accepted):
N = int(input())
A = int(input())
result = N**2 - A
print(str(result))
Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
A = int(input())
brack = N ** N - A
print(brack)

Failing test case input:
19
100

Expected output:
261

Actual output:
1978419655660313589123879


Fixed submission (verdict: Accepted):
n = int(input())
a = int(input())
brack = n ** 2 - a
print(brack)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
a = int(input())
print(n - a)

Failing test case input:
3
14

Expected output:
-5


Actual output:
-11


Fixed submission (verdict: Accepted):
n = int(input())
a = int(input())
print(n * n - a)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n=int(input())
a=int(input())
print(n**-a)

Failing test case input:
3
20

Expected output:
-11


Actual output:
2.8679719907924413e-10


Fixed submission (verdict: Accepted):
n=int(input())
a=int(input())
print(n**2-a)

Problem: p03597
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
N=int(input())
K=int(input())
print(N*2-K)

Failing test case input:
10
121

Expected output:
-21


Actual output:
-101


Fixed submission (verdict: Accepted):
N=int(input())
K=int(input())
print(N**2-K)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
print(int(input())*2 - int(input()))

Failing test case input:
10
174

Expected output:
-74


Actual output:
-154


Fixed submission (verdict: Accepted):
print(int(input())**2 - int(input()))

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=[int(input()) for i in range(2)]
print(a*2-b)

Failing test case input:
3
-177

Expected output:
186


Actual output:
183


Fixed submission (verdict: Accepted):
a,b=[int(input()) for i in range(2)]
print(a*a-b)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
value_list = []
number_of_test = int(input())
number_of_test2 = int(input())

print((number_of_test*number_of_test)-number_of_test)


Failing test case input:
3
7

Expected output:
2


Actual output:
6


Fixed submission (verdict: Accepted):
number_of_test = int(input())
number_of_test2 = int(input())

print((number_of_test*number_of_test)-number_of_test2)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
A = int(input())
print(N^2-A)

Failing test case input:
10
137

Expected output:
-37


Actual output:
-141


Fixed submission (verdict: Accepted):
N = int(input())
A = int(input())
print(N**2-A)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
A = int(input())
print(N-A**2)

Failing test case input:
3
-40

Expected output:
49


Actual output:
-1597


Fixed submission (verdict: Accepted):
N = int(input())
A = int(input())
print(N**2-A)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
A = int(input())

print(N-A)

Failing test case input:
3
18

Expected output:
-9


Actual output:
-15


Fixed submission (verdict: Accepted):
N = int(input())
A = int(input())

print(N*N-A)
Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
A = int(input())
print(N*2-A)


Failing test case input:
3
12

Expected output:
-3


Actual output:
-6


Fixed submission (verdict: Accepted):
N = int(input())
A = int(input())
print(N**2-A)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
a = int(input())

print(n * 2 - a)

Failing test case input:
3
-58

Expected output:
67


Actual output:
64


Fixed submission (verdict: Accepted):
n = int(input())
a = int(input())

print(n ** 2 - a)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n=int(input())
a=int(input())
print(n**-a)

Failing test case input:
3
5

Expected output:
4


Actual output:
0.00411522633744856


Fixed submission (verdict: Accepted):
n=int(input())
a=int(input())
print(n**2-a)

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


n = int(input())
a = int(input())

print(n**2-4)


Failing test case input:
3
25

Expected output:
-16


Actual output:
5


Fixed submission (verdict: Accepted):


n = int(input())
a = int(input())

print(n**2-a)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n=int(input())
nn=n**n
a=int(input())
print(nn-a)

Failing test case input:
3
-29

Expected output:
38


Actual output:
56


Fixed submission (verdict: Accepted):
n=int(input())

a=int(input())

print(n**2-a)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N, A = map(int, [input() for _ in range(2)])
print(N ** N - A)


Failing test case input:
3
16

Expected output:
-7


Actual output:
11


Fixed submission (verdict: Accepted):
N, A = map(int, [input() for _ in range(2)])
print(N ** 2 - A)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n=int(input())
a=int(input())
print(n**-a)

Failing test case input:
3
15

Expected output:
-6


Actual output:
6.969171937625632e-08


Fixed submission (verdict: Accepted):
n=int(input())
a=int(input())
print(n**2-a)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n=int(input())
a=int(input())
print(n^2-a)

Failing test case input:
3
14

Expected output:
-5


Actual output:
-9


Fixed submission (verdict: Accepted):
n=int(input())
a=int(input())
print(int(n**2-a))

Problem: p03597
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
N = int(input())
A = int(input())
print(N * 2 - A)

Failing test case input:
3
16

Expected output:
-7


Actual output:
-10


Fixed submission (verdict: Accepted):
N = int(input())
A = int(input())
print(N * N - A)

Problem: p03597
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
x=int(input())
y=int(input())
x*x-y

Failing test case input:
3
12

Expected output:
-3


Actual output:

Fixed submission (verdict: Accepted):
x=int(input())
y=int(input())
print(x**2-y)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
A = int(input())
print(N-A)

Failing test case input:
3
-29

Expected output:
38


Actual output:
32


Fixed submission (verdict: Accepted):
N = int(input())
A = int(input())
print(N**2-A)
Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N=int(input())
A=int(input())

print((N*2)-A)

Failing test case input:
3
16

Expected output:
-7


Actual output:
-10


Fixed submission (verdict: Accepted):
N=int(input())
A=int(input())

print((N*N)-A)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
a = int(input())

print(n**n - a)

Failing test case input:
3
17

Expected output:
-8


Actual output:
10


Fixed submission (verdict: Accepted):
n = int(input())
a = int(input())

print(n**2 - a)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
A = int(input())
print(N*2-A)

Failing test case input:
10
202

Expected output:
-102


Actual output:
-182


Fixed submission (verdict: Accepted):
N = int(input())
A = int(input())
print((N**2)-A)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
a = int(input())
print((n**n)-1)

Failing test case input:
3
22

Expected output:
-13


Actual output:
26


Fixed submission (verdict: Accepted):
n = int(input())
a = int(input())
print((n**2)-a)

Problem: p03597
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
n = int(input())
a = int(input())
print(n**-a)

Failing test case input:
3
-58

Expected output:
67


Actual output:
4710128697246244834921603689


Fixed submission (verdict: Accepted):
n = int(input())
a = int(input())
print(n**2-a)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n=int(input())
a=int(input())
print(n*2-a)

Failing test case input:
3
31

Expected output:
-22


Actual output:
-25


Fixed submission (verdict: Accepted):
n=int(input())
a=int(input())
print(n**2-a)

Problem: p03597
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N, A = [int(input()) for i in range(2)]
print(N ^ 2 - A)

Failing test case input:
3
17

Expected output:
-8


Actual output:
-14


Fixed submission (verdict: Accepted):
N, A = [int(input()) for i in range(2)]
print(pow(N, 2) - A)

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


def main():
    n = int(input())
    a = int(input())

    print(n ** n - a)

if __name__ == '__main__':
    main()

Failing test case input:
3
9

Expected output:
0


Actual output:
18


Fixed submission (verdict: Accepted):


def main():
    n = int(input())
    a = int(input())

    print(n * n - a)

if __name__ == '__main__':
    main()

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n=int(input())
a=int(input())
print(int(n^2-a))

Failing test case input:
3
-51

Expected output:
60


Actual output:
54


Fixed submission (verdict: Accepted):
n=int(input())
a=int(input())
print(int(n**2-a))

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
a = int(input())
print(n * 2 - a)

Failing test case input:
3
9

Expected output:
0


Actual output:
-3


Fixed submission (verdict: Accepted):
n = int(input())
a = int(input())
print(n * n - a)
Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = int(input())
A = int(input())
print(N**N - A)

Failing test case input:
3
20

Expected output:
-11


Actual output:
7


Fixed submission (verdict: Accepted):
n = int(input())
a = int(input())

print(n**2 -a)

Problem: p03597
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
A = int(input())
N = int(input())
print(N**2 - N)

Failing test case input:
3
31

Expected output:
-22


Actual output:
930


Fixed submission (verdict: Accepted):
A = int(input())
N = int(input())
print(A**2 - N)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
a = int(input())
print(n*2 - a)

Failing test case input:
3
15

Expected output:
-6


Actual output:
-9


Fixed submission (verdict: Accepted):
n = int(input())
a = int(input())
print(n*n - a)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
a = int(input())
print = (n*n-a)

Failing test case input:
3
-22

Expected output:
31


Actual output:

Fixed submission (verdict: Accepted):
n = int(input())
a = int(input())
print(n**2-a)

Problem: p03597
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = int(input())
a = int(input())
print(a**2-a)



Failing test case input:
3
5

Expected output:
4


Actual output:
20


Fixed submission (verdict: Accepted):
n = int(input())
a = int(input())
print(n**2-a)
Problem: p02364
Buggy submission (Python3, verdict: Wrong Answer):
def find_tree(v):
    for tree in forest:
        if v in tree:
            return tree

nv, ne = map(int, input().split(' '))
edges = []
for i in range(ne):
    s, t, w = map(int, input().split(' '))
    edges.append((s, t, w))

sum = 0
forest = [[v] for v in range(nv)]
edges.sort(key=lambda tup: tup[2])
for s, t, w in edges:
    u = find_tree(s)
    v = find_tree(t)
    if u != v:
        [u.append(i) for i in v]
        forest.remove(v)
        sum += w
    if len(forest) == 1:
        print(sum)
        exit()

Failing test case input:
6 2
0 1 1
0 2 3
1 2 2
1 3 7
2 4 1
2 4 3
3 2 0
3 9 1
2 5 10

Expected output:
4


Actual output:

Fixed submission (verdict: Accepted):
def find(x):
    if vertices[x] != x:
        vertices[x] = find(vertices[x])
    return vertices[x]

nv, ne = map(int, input().split(' '))
vertices = [i for i in range(nv)]
edges = []
for i in range(ne):
    s, t, w = map(int, input().split(' '))
    edges.append((s, t, w))

sum = 0
forest = [[v] for v in range(nv)]
edges.sort(key=lambda tup: tup[2])
for s, t, w in edges:
    u = find(s)
    v = find(t)
    if u != v:
        vertices[u] = v
        sum += w

print(sum)

Problem: p02364
Buggy submission (Python3, verdict: Wrong Answer):




V, E = map(int, input().split())
D = 0
vertices = []
for i in range(V):
    vertices.append(i)          

edges = []
for i in range(E):
    s, t, d = map(int, input().split())
    edges.append((s, t, d))

edges.sort(key=lambda x: x[2])
while edges:
    if V == 0:
        break
    s, t, d = edges.pop(0)
    if vertices[s] != vertices[t]:
        vertices[s] = vertices[t] = min(vertices[s], vertices[t])
        D += d
        V -= 1
print(D)

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

Expected output:
3


Actual output:
5


Fixed submission (verdict: Accepted):


from collections import defaultdict


V, E = map(int, input().split())
D = 0
tree = []
vertices = defaultdict(set)
for i in range(V):
    tree.append(i)          
    vertices[i].add(i)

edges = []
for i in range(E):
    s, t, d = map(int, input().split())
    edges.append((s, t, d))

edges.sort(key=lambda x: x[2])
while edges:
    if V == 1:
        break
    s, t, d = edges.pop(0)
    if tree[s] != tree[t]:
        new = min(tree[s], tree[t])
        old = max(tree[s], tree[t])
        vertices[new] = vertices[new] | vertices[old]
        for vertex in vertices[old]:
            tree[vertex] = new

        D += d
        V -= 1
print(D)
Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=list(map(int,input().split()))
a.sort
print(sum(a[0:2]))

Failing test case input:
011 -84 1

Expected output:
-83


Actual output:
-73


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

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
p = list(map(int,input().split()))
l=[p[i]*p[j] for i in range(3) for j in range(i+1,3)]
print(min(l))

Failing test case input:
1 -6 4

Expected output:
-5


Actual output:
-24


Fixed submission (verdict: Accepted):
p = list(map(int,input().split()))
l=[p[i]+p[j] for i in range(3) for j in range(i+1,3)]
print(min(l))

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

Failing test case input:
46 26 0

Expected output:
26


Actual output:
52


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

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
P , Q , R = map(int, input().split())

if P > Q and P > R:
    print(Q + R)
elif Q > P and Q > R:
    print(P + R)
else:
    print(P + Q)

Failing test case input:
0 0 -14

Expected output:
-14


Actual output:
0


Fixed submission (verdict: Accepted):
P , Q , R = map(int, input().split())

if P >= Q and P >= R:
    print(Q + R)
elif Q >= P and Q >= R:
    print(P + R)
else:
    print(P + Q)

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
t_list=[]
is_arg_ok = False
try:
  t_list = [int(n) for n in input().split(' ')]
except:
  print('age,price must be numbers')
  sys.exit(1)

min_1 = 10000
min_2 = 10000
for i in range(len(t_list)):
    t1 = t_list[i]
    if min_1 > t1:
        min_1 = t1
    elif min_2 > t1:
        min_2 = t1
min_t = min_1 + min_2
print(min_t)

Failing test case input:
5 84 3

Expected output:
8


Actual output:
87


Fixed submission (verdict: Accepted):
t_list=[]
is_arg_ok = False
try:
  t_list = [int(n) for n in input().split(' ')]
except:
  print('age,price must be numbers')
  sys.exit(1)

min_1 = 10000
min_2 = 10000
for i in range(len(t_list)):
    t1 = t_list[i]
    if min_1 > t1:
        min_2 = min_1
        min_1 = t1
    elif min_2 > t1:
        min_2 = t1
min_t = min_1 + min_2
print(min_t)

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = [ int(x) for x in input().split() ]
print( sum( S ) - min( S ) )

Failing test case input:
001 -12 -77

Expected output:
-89


Actual output:
-11


Fixed submission (verdict: Accepted):
S = [ int(x) for x in input().split() ]
print( sum( S ) - max( S ) )

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


A_B, B_C, C_A = (int(a) for a in input().split())

P = A_B + B_C
Q = B_C + C_A

if P < Q:
    print(P)
else:
    print(Q)

Failing test case input:
5 84 3

Expected output:
8


Actual output:
87


Fixed submission (verdict: Accepted):


A_B, B_C, C_A = (int(a) for a in input().split())

ans = (A_B + B_C + C_A) - max(A_B, B_C, C_A)
print(ans)
Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a2b , b2c, c2a = map(int,input().split())
if b2c <= a2b and c2a <= a2b:
    print(b2c + c2a)
if a2b < b2c and  c2a < b2c:
    print(a2b + c2a)
if b2c < c2a and a2b < c2a:
    print(b2c + a2b)

Failing test case input:
-64 1 1

Expected output:
-63


Actual output:

Fixed submission (verdict: Accepted):
a2b , b2c, c2a = map(int,input().split())
if b2c <= a2b and c2a <= a2b:
    print(b2c + c2a)
if a2b < b2c and  c2a <= b2c:
    print(a2b + c2a)
if b2c < c2a and a2b < c2a:
    print(b2c + a2b)

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
p,q,r = map(int,input().split())

print(min(p+q,p+r,r*q))


Failing test case input:
010 -10 -28

Expected output:
-38


Actual output:
-18


Fixed submission (verdict: Accepted):
p,q,r = map(int,input().split())

print(min(p+q,p+r,r+q))

Problem: p03011
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n=list(map(int, input().strip().split()))

lis1=[]
for i in range(0,len(n)):
    for a in range(0,len(n)):
        if n[i]!=n[a]:
            z=(int(n[a])+int(n[i]))
            lis1.append(z)

minscore='9999999999'
for i in range(0,len(lis1)):
    if float(minscore)>float(lis1[i]):
        minscore=lis1[i]

print(minscore)



Failing test case input:
010 -10 -10

Expected output:
-20


Actual output:
0


Fixed submission (verdict: Accepted):
try:
    n=list(map(int, input().strip().split()))
    lis1=[]
    for i in range(0,len(n)):
        for a in range(0,len(n)):
            if a!=i:
                z=(int(n[a])+int(n[i]))
                lis1.append(z)
            
    minscore='9999999999'
    for i in range(0,len(lis1)):
        if float(minscore)>float(lis1[i]):
            minscore=lis1[i]
    
    print(minscore)
    
except:
    print('')

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
p,q,r = map(int,input().split())
print(min(p+q,q+r,r+q))

Failing test case input:
-28 1 -2

Expected output:
-30


Actual output:
-27


Fixed submission (verdict: Accepted):
p,q,r = map(int,input().split())
print(min(p+q,q+r,r+p))

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
P, Q, R = map(int, input().split())
min(P+Q, P+R, Q+R)

Failing test case input:
0 0 -14

Expected output:
-14


Actual output:

Fixed submission (verdict: Accepted):
P, Q, R = map(int, input().split())
print(min(P+Q, P+R, Q+R))

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
data = list(map(int, input().split()))
n = len(data)
res = max(data)
for i in range(n-1):
  for j in range(i, n):
    if data[i] + data[j] < res:
      res = data[i] + data[j]
print(res)
    

Failing test case input:
-49 1 2

Expected output:
-48


Actual output:
-98


Fixed submission (verdict: Accepted):
data = list(map(int, input().split()))
n = len(data)
res = 300
for i in range(n-1):
  for j in range(i+1, n):
    if data[i] + data[j] < res:
      res = data[i] + data[j]
print(res)
Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
p, q, r = map(int, input().split())

print(min(p+q, q+r, r+q))


Failing test case input:
-64 1 0

Expected output:
-64


Actual output:
-63


Fixed submission (verdict: Accepted):
p, q, r = map(int, input().split())

print(min(p+q, q+r, r+p))

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
P, Q, R = map(int, input().split())
print(max(P+Q, Q+R, R+P))

Failing test case input:
38 1 -8

Expected output:
-7


Actual output:
39


Fixed submission (verdict: Accepted):
P, Q, R = map(int, input().split())
print(min(P+Q, Q+R, R+P))

Problem: p03011
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:
-25 -1 1

Expected output:
-26


Actual output:
0


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

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

Failing test case input:
-19 010 1

Expected output:
-18


Actual output:

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

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
data = list(map(int, input().split()))
n = len(data)
res = 0
for i in range(n-1):
  for j in range(i, n):
    if data[i] + data[j] < res:
      res = data[i] + data[j]
print(res)
    

Failing test case input:
000 -93 -7

Expected output:
-100


Actual output:
-186


Fixed submission (verdict: Accepted):
data = list(map(int, input().split()))
n = len(data)
res = 300
for i in range(n-1):
  for j in range(i+1, n):
    if data[i] + data[j] < res:
      res = data[i] + data[j]
print(res)

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
r_l=list(map(int,input().split()))
 
min_r=1000

for i in range(3):
  for j in range(i+1,3-1,1):
    min_r=min(r_l[i]+r_l[j],min_r)

print(min_r)
  

Failing test case input:
3 1 0

Expected output:
1


Actual output:
4


Fixed submission (verdict: Accepted):
r_l=list(map(int,input().split()))
 
min_r=1000

for i in range(3):
  for j in range(i+1,3,1):
    min_r=min(r_l[i]+r_l[j],min_r)

print(min_r)

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
lst = list(input().split())

A = lst[0] + lst[1]
B = lst[1] + lst[2]
C = lst[0] + lst[2]

print(min([A,B,C]))

Failing test case input:
14 10 2

Expected output:
12


Actual output:
102


Fixed submission (verdict: Accepted):
p,q,r = map(int,input().split())    
lst = [p,q,r]

A = lst[0] + lst[1]
B = lst[1] + lst[2]
C = lst[0] + lst[2]

print(min([A,B,C]))
Problem: p03011
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
p,q,r=map(int,input().split())
if p>=q and  p>r:
    print(q+r)
if q>=p and q>r:
    print(p+r)
if r>=q and r>p:
    print(q+p)
if r==p and p==q:
    print(p+q)        

Failing test case input:
0 0 -14

Expected output:
-14


Actual output:
-14
-14


Fixed submission (verdict: Accepted):
p,q,r=map(int,input().split())
if p>=q and p>r:
    print(q+r)
if q>=r and q>p:
    print(p+r)
if r>=p and r>q:
    print(q+p)
if r==p and p==q:
    print(q+p)

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
P, Q, R = map(int, input().split())

ans = P+Q if P+Q < R+Q else R+Q
print(ans)


Failing test case input:
1 6 5

Expected output:
6


Actual output:
7


Fixed submission (verdict: Accepted):
P, Q, R = map(int, input().split())

ans = P+Q if P+Q < R+Q else R+Q
ans = P+R if P+R < ans else ans
print(ans)

Problem: p03011
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:
011 -48 1

Expected output:
-47


Actual output:
-37


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

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys
data = sys.stdin.readlines()
print(data[0].split())
inputs = [int(x) for x in data[0].split()]
inputs.sort()
print(inputs[0] + inputs[1])

Failing test case input:
010 -10 -10

Expected output:
-20


Actual output:
['010', '-10', '-10']
-20


Fixed submission (verdict: Accepted):
import sys
data = sys.stdin.readlines()
inputs = [int(x) for x in data[0].split()]
inputs.sort()
print(inputs[0] + inputs[1])

Problem: p03011
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
p, q, r = map(int, input().split())
print(min(p+q, q+r, q+p))

Failing test case input:
33 38 -1

Expected output:
32


Actual output:
37


Fixed submission (verdict: Accepted):
p, q, r = map(int, input().split())
print(min(p+q, q+r, r+p))

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
P,Q,R = list(map(int,input().split()))
if P+Q <= Q+R & P+Q <= P+R :
    print(P+Q)
elif P+R <= P+Q & P+R <= Q+R :
    print(P+R)
else :
    print(Q+R) 


Failing test case input:
-33 1 0

Expected output:
-33


Actual output:
1


Fixed submission (verdict: Accepted):
P,Q,R = list(map(int,input().split()))
if P+Q <= Q+R and P+Q <= P+R :
    print(P+Q)
elif P+R <= P+Q and P+R <= Q+R :
    print(P+R)
elif Q+R <= P+Q and Q+R <= P+Q :
    print(Q+R)

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
p,q,r = map(int, input().split())
print(max(p+q, r))

Failing test case input:
010 -5 -36

Expected output:
-41


Actual output:
5


Fixed submission (verdict: Accepted):
p,q,r = map(int, input().split())
print(min(p+q,q+r,r+p))

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
p,q,r=map(int,input().split())
ans=min(p*2,q*2,r*2,p+q,q+r,r+p)

Failing test case input:
77 18 0

Expected output:
18


Actual output:

Fixed submission (verdict: Accepted):
p,q,r=map(int,input().split())
ans=min(p+q,q+r,r+p)
print(ans)
Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
p, q, r = map(int, input().split())
print(min(p + q, p + r, r + p))

Failing test case input:
010 -10 -18

Expected output:
-28


Actual output:
-8


Fixed submission (verdict: Accepted):
p, q, r = map(int, input().split())
print(min(p + q, q + r, r + p))

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
p,q,r = map(int,input().split())

print(min(p+q,q+r,r+q))

Failing test case input:
-64 1 0

Expected output:
-64


Actual output:
-63


Fixed submission (verdict: Accepted):
p,q,r = map(int,input().split())

print(min(p+q,q+r,r+p))

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
P, Q, R = map(int, input().split())
print(min(P+Q, Q+R, Q+R))

Failing test case input:
9 84 2

Expected output:
11


Actual output:
86


Fixed submission (verdict: Accepted):
P, Q, R = map(int, input().split())
print(min(P+Q, Q+R, P+R))

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
p,q,r=map(int,input().split())
print(max([p+q,q+r,r+p]))

Failing test case input:
010 -1 -36

Expected output:
-37


Actual output:
9


Fixed submission (verdict: Accepted):
p,q,r=map(int,input().split())
print(min([p+q,q+r,r+p]))

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

Failing test case input:
38 -1 -9

Expected output:
-10


Actual output:
19


Fixed submission (verdict: Accepted):
p,q,r = map(int,input().split())
a = p+q
b = q+r
c = r+p
l=[a,b,c]

print(min(l))

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

Failing test case input:
33 38 -1

Expected output:
32


Actual output:
37


Fixed submission (verdict: Accepted):
a,b,c = map(int,input().split())
k = a + b
l = c + b
o = a + c
print(min(k,l,o))
Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):


import sys

debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False
        lines.append(input())
    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]


    token = lines[0].split()
    a = int(token[0])
    b = int(token[1])
    c = int(token[2])

    return (a, b, c)


def solve(a, b, c):

        

    

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




def main():
    

    print("%s" % solve(*parse_input()))

if __name__ == '__main__':

    main()
	

Failing test case input:
38 -1 -8

Expected output:
-9


Actual output:
30


Fixed submission (verdict: Accepted):


import sys

debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False
        lines.append(input())
    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]


    token = lines[0].split()
    a = int(token[0])
    b = int(token[1])
    c = int(token[2])

    return (a, b, c)


def solve(a, b, c):

        

    

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




def main():
    

    print("%s" % solve(*parse_input()))

if __name__ == '__main__':

    main()

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
data = list(map(int, input().split()))
data.sort()

print(sum(data[:1]))

Failing test case input:
33 38 -1

Expected output:
32


Actual output:
-1


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

print(sum(data[:2]))

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import itertools
P, Q, R = tuple(map(int, input().split()))

min_val = P + Q
if min_val > Q + R:
    min_val = Q + R
elif min_val > P + R:
    min_val = P + R
print(min_val)

Failing test case input:
18 24 2

Expected output:
20


Actual output:
26


Fixed submission (verdict: Accepted):
import itertools
P, Q, R = tuple(map(int, input().split()))

min_val = P + Q
if min_val > Q + R:
    min_val = Q + R
if min_val > P + R:
    min_val = P + R
print(min_val)

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import itertools

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

combos = itertools.combinations(routes,2)

time = []
for c in combos:
    time.append(c[0] + c[1])
    
min(time)

Failing test case input:
011 -23 1

Expected output:
-22


Actual output:

Fixed submission (verdict: Accepted):
import itertools

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

combos = itertools.combinations(routes,2)

time = []
for c in combos:
    time.append(c[0] + c[1])
    
print(min(time))

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

N.sort

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

Failing test case input:
101 -71 -6

Expected output:
-77


Actual output:
30


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

N.sort()

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

Failing test case input:
8 20 2

Expected output:
10


Actual output:
28


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

Problem: p03011
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
p, q, r = map(int, input().split())
if p > q and p > r:
    print(q + r)
elif q > p and q > r:
    print(p + r)
else:
    print(p + q)

Failing test case input:
1 1 -14

Expected output:
-13


Actual output:
2


Fixed submission (verdict: Accepted):
p, q, r = map(int, input().split())
if p >= q and p >= r:
    print(q + r)
elif q >= p and q >= r:
    print(p + r)
else:
    print(p + q)

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

ans = float('inf')

for i in range(3):
    for j in range(3):
        if i != j:
            if ans > a[i] + a[j]:
                print(a[i],a[j])
                ans = a[i] + a[j]

print(ans)

Failing test case input:
77 18 0

Expected output:
18


Actual output:
77 18
77 0
18 0
18


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

ans = float('inf')

for i in range(3):
    for j in range(3):
        if i != j:
            if ans > a[i] + a[j]:
                ans = a[i] + a[j]

print(ans)

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
p,q,r = map(int,input().split())

min = p + q

if (min > q + r):
    min = q + r
elif (min > r + p):
    min = r + p

print (min)

Failing test case input:
7 20 2

Expected output:
9


Actual output:
22


Fixed submission (verdict: Accepted):
p,q,r = map(int,input().split())

min = p + q

if (min >= q + r):
    min = q + r
if (min >= r + p):
    min = r + p

print (int(min))

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
p,q,r = map(int,input().split())

min = p + q

if (min >= q + r):
    min = q + r
elif (min >= r + p):
    min = r + p

print (int(min))

Failing test case input:
33 38 -1

Expected output:
32


Actual output:
37


Fixed submission (verdict: Accepted):
p,q,r = map(int,input().split())

min = p + q

if (min >= q + r):
    min = q + r
if (min >= r + p):
    min = r + p

print (int(min))
Problem: p03011
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
try:
    n=list(map(int, input().strip().split()))
    lis1=[]
    for i in range(0,len(n)):
        for a in range(0,len(n)):
            z=(int(n[a])+int(n[i]))
            lis1.append(z)
    set1=set((lis1))
    lis1=list((set1))
    minscore='9999999999'
    for i in range(0,len(lis1)):
        if float(minscore)>float(lis1[i]):
            minscore=lis1[i]
    
    print(minscore)
    
except:
    print('')



Failing test case input:
46 26 0

Expected output:
26


Actual output:
0


Fixed submission (verdict: Accepted):
try:
    n=list(map(int, input().strip().split()))
    lis1=[]
    for i in range(0,len(n)):
        for a in range(0,len(n)):
            if a!=i:
                z=(int(n[a])+int(n[i]))
                lis1.append(z)
            
    minscore='9999999999'
    for i in range(0,len(lis1)):
        if float(minscore)>float(lis1[i]):
            minscore=lis1[i]
    
    print(minscore)
    
except:
    print('')

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
p,q,r=map(int,input().split())
ans=min(p*2,q*2,r*2,p+q,q+r,r+p)
print(ans)

Failing test case input:
46 38 0

Expected output:
38


Actual output:
0


Fixed submission (verdict: Accepted):
p,q,r=map(int,input().split())
ans=min(p+q,q+r,r+p)
print(ans)

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,C = map(int,input().split())
print(A + B + C + max([A,B,C]))

Failing test case input:
010 -39 -5

Expected output:
-44


Actual output:
-24


Fixed submission (verdict: Accepted):
A,B,C = map(int,input().split())
print(A + B + C - max([A,B,C]))

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
PQR = list(map(int, input().split()))
PQR.sort()
print(sum(PQR[:1]))


Failing test case input:
46 26 0

Expected output:
26


Actual output:
0


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

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
num_list = [int(i) for i in input().split()]

LEN = 3
abc_sum = 0
for i in range(len(num_list) - 1):
  abc_sum += num_list[i]

bca_sum = 0
reversed_list = list(reversed(num_list))
for i, num in enumerate(reversed_list, 1):
  if i == LEN:
    break
  bca_sum += num

cab_sum = 0
cab_sum += num_list[-1]
cab_sum += num_list[0]

min = abc_sum
if abc_sum > bca_sum:
  min = bca_sum
elif abc_sum > cab_sum:
  min = cab_sum
print(min)

Failing test case input:
5 84 3

Expected output:
8


Actual output:
87


Fixed submission (verdict: Accepted):
num_list = [int(i) for i in input().split()]

LEN = 3
abc_sum = 0
for i in range(len(num_list) - 1):
  abc_sum += num_list[i]

bca_sum = 0
reversed_list = list(reversed(num_list))
for i, num in enumerate(reversed_list, 1):
  if i == LEN:
    break
  bca_sum += num

cab_sum = 0
cab_sum += num_list[-1]
cab_sum += num_list[0]

l = [abc_sum, bca_sum, cab_sum]

print(min(l))
Problem: p03011
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
try:
    n=list(map(int, input().strip().split()))
    for i in range(0,len(n)):
        if int(n[i])<1 or int(n[i])>100:
            raise AssertionError

    lis1=[]
    for i in range(0,len(n)):
        for a in range(0,len(n)):
            if n[i]!=n[a]:
                z=(int(n[a])+int(n[i]))
                lis1.append(z)

    minscore='9999999999'
    for i in range(0,len(lis1)):
        if float(minscore)>float(lis1[i]):
            minscore=lis1[i]

    print(minscore)
except AssertionError:
    print('')



Failing test case input:
001 -10 -77

Expected output:
-87


Actual output:

Fixed submission (verdict: Accepted):
try:
    n=list(map(int, input().strip().split()))
    lis1=[]
    for i in range(0,len(n)):
        for a in range(0,len(n)):
            if a!=i:
                z=(int(n[a])+int(n[i]))
                lis1.append(z)
            
    minscore='9999999999'
    for i in range(0,len(lis1)):
        if float(minscore)>float(lis1[i]):
            minscore=lis1[i]
    
    print(minscore)
    
except:
    print('')

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
p,q,r=map(int,input().split())
print(min(p+q,r+q))


Failing test case input:
-33 1 0

Expected output:
-33


Actual output:
-32


Fixed submission (verdict: Accepted):
p,q,r=map(int,input().split())
print(min(p+q,r+q,p+r,p+r))

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

A = int(S[0])
B = int(S[1])
C = int(S[2])
answer_1 = A + B
answer_2 = A + C
answer_3 = B + C

print(max(answer_1,answer_2,answer_3))


Failing test case input:
14 84 2

Expected output:
16


Actual output:
98


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

A = int(S[0])
B = int(S[1])
C = int(S[2])
answer_1 = A + B
answer_2 = A + C
answer_3 = B + C

print(min(answer_1,answer_2,answer_3))

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
L=list(input())
L.sort()
print(L[0]+L[1])

Failing test case input:
46 24 0

Expected output:
24


Actual output:

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

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
p, q, r = map(int, input().split())
a = p + q
b = q + r
print(min(a, b))


Failing test case input:
-64 1 0

Expected output:
-64


Actual output:
-63


Fixed submission (verdict: Accepted):
p, q, r = map(int, input().split())

a = [
    p + q,
    p + r,
    q + r,
]
print(min(a))

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

Failing test case input:
3 1 0

Expected output:
1


Actual output:
4


Fixed submission (verdict: Accepted):
a = list(map(int, input().split()))
a.sort()
b = int(a[0]) + int(a[1])
print(b)
Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
p, q, r = map(int, input().split())
if p + q < q + r:
    print(p + q)
else:
    print(q + r)

Failing test case input:
11 24 2

Expected output:
13


Actual output:
26


Fixed submission (verdict: Accepted):
p, q, r = map(int, input().split())
m = p + q
if m > min(q + r, r + p):
    m = min(q + r, r + p)
print(m)

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
num_list = [int(i) for i in input().split()]

LEN = 3
abc_sum = 0
for i in range(len(num_list) - 1):
  abc_sum += num_list[i]

bca_sum = 0
reversed_list = list(reversed(num_list))
for i, num in enumerate(reversed_list, 1):
  if i == LEN:
    break
  bca_sum += num

cab_sum = 0
cab_sum += num_list[-1]
cab_sum += num_list[0]

min = abc_sum
if abc_sum > bca_sum:
  min = bca_sum
elif bca_sum > cab_sum:
  min = cab_sum
print(min)

Failing test case input:
7 20 2

Expected output:
9


Actual output:
22


Fixed submission (verdict: Accepted):
num_list = [int(i) for i in input().split()]

LEN = 3
abc_sum = 0
for i in range(len(num_list) - 1):
  abc_sum += num_list[i]

bca_sum = 0
reversed_list = list(reversed(num_list))
for i, num in enumerate(reversed_list, 1):
  if i == LEN:
    break
  bca_sum += num

cab_sum = 0
cab_sum += num_list[-1]
cab_sum += num_list[0]

l = [abc_sum, bca_sum, cab_sum]

print(min(l))

Problem: p03011
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
p,q,r=map(int,input().split())
if p+q<q+r and p+q<p+r:
    print(p+q)
if p+r<p+q and p+r<q+r:
    print(p+r)
if q+r<p+r and q+r<p+q:
    print(q+r)

Failing test case input:
0 0 -14

Expected output:
-14


Actual output:

Fixed submission (verdict: Accepted):
p,q,r=map(int,input().split())
if p>=q and p>r:
    print(q+r)
if q>=r and q>p:
    print(p+r)
if r>=p and r>q:
    print(q+p)
if r==p and p==q:
    print(q+p)

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
P,Q,R=map(int,input().split())
ans=[]
ans.append(P)
ans.append(Q)
ans.append(R)

sorted(ans)
print(ans[0]+ans[1])

Failing test case input:
000 -93 -7

Expected output:
-100


Actual output:
-93


Fixed submission (verdict: Accepted):
P,Q,R=map(int,input().split())
ans=[]
ans.append(P)
ans.append(Q)
ans.append(R)

sorted(ans)
print(P+Q+R-max(ans))

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
p,q,r = map(int, input().split())
a = min(p,q,r)
print(p+q+r-a)

Failing test case input:
9 84 2

Expected output:
11


Actual output:
93


Fixed submission (verdict: Accepted):
p,q,r = map(int, input().split())
a = max(p,q,r)
print(p+q+r-a)

Problem: p03011
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
p,q,r = map(int,input().split())
print(min(p+q,q+r))

Failing test case input:
1 6 5

Expected output:
6


Actual output:
7


Fixed submission (verdict: Accepted):
p,q,r = map(int,input().split())
print(min(p+q,q+r,p+r))