TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: A sequence a_1,a_2,... ,a_n is said to be /\/\/\/ when the following conditions are satisfied:    * For each i = 1,2,..., n-2, a_i = a_{i+2}.   * Exactly two different numbers appear in the sequence.  You are given a sequence v_1,v_2,...,v_n whose length is even. We would like to make this sequence /\/\/\/ by replacing some of its elements. Find the minimum number of elements that needs to be replaced.

Submission attempts (in order):
n = int(input())
v = list(map(int,input().split()))

v_e_cnt = [0 for i in range(10**6)]
v_o_cnt = [0 for i in range(10**6)]
for x in range(n):
	if x % 2 == 0:
		v_e_cnt[v[x]] += 1
	else:
		v_o_cnt[v[x]] += 1

max_e = [(0,0),(0,0)]
max_o = [(0,0),(0,0)]
for i in range(10**5+1):
	if max_e[1][0] < v_e_cnt[i]:
		if max_e[0][0] < v_e_cnt[i]:
			max_e[1] = max_e[0]
			max_e[0] = (v_e_cnt[i], i)
		else:
			max_e[1] = (v_e_cnt[i], i)
	if max_o[1][0] < v_o_cnt[i]:
		if max_o[0][0] > v_o_cnt[i]:
			max_o[1] = max_o[0]
			max_o[0] = (v_o_cnt[i], i)
		else:
			max_o[0] = (v_o_cnt[i], i)

ans = n - e[0][0] - o[0][0]
if e[0][1] == o[0][1]:
	ans = n - max(e[0][0] + o[1][0], e[1][0] + o[0][0])

print(ans)


n = int(input())
v = list(map(int,input().split()))

v_e_cnt = [0 for i in range(10**6)]
v_o_cnt = [0 for i in range(10**6)]
for x in range(n):
	if x % 2 == 0:
		v_e_cnt[v[x]] += 1
	else:
		v_o_cnt[v[x]] += 1

max_e = [(0,0),(0,0)]
max_o = [(0,0),(0,0)]
for i in range(10**5+1):
	if max_e[1][0] < v_e_cnt[i]:
		if max_e[0][0] < v_e_cnt[i]:
			max_e[1] = max_e[0]
			max_e[0] = (v_e_cnt[i], i)
		else:
			max_e[1] = (v_e_cnt[i], i)
	if max_o[1][0] < v_o_cnt[i]:
		if max_o[0][0] > v_o_cnt[i]:
			max_o[1] = max_o[0]
			max_o[0] = (v_o_cnt[i], i)
		else:
			max_o[1] = (v_o_cnt[i], i)

ans = n - max_e[0][0] - max_o[0][0]
if max_e[0][1] == max_o[0][1]:
	ans = n - max(max_e[0][0] + max_o[1][0], max_e[1][0] + max_o[0][0])

print(ans)


n = int(input())
v = list(map(int,input().split()))

v_e_cnt = [0 for i in range(10**6)]
v_o_cnt = [0 for i in range(10**6)]
for x in range(n):
	if x % 2 == 0:
		v_e_cnt[v[x]] += 1
	else:
		v_o_cnt[v[x]] += 1

max_e = [(0,0),(0,0)]
max_o = [(0,0),(0,0)]
for i in range(10**5+1):
	if max_e[1][0] < v_e_cnt[i]:
		if max_e[0][0] < v_e_cnt[i]:
			max_e[1] = max_e[0]
			max_e[0] = (v_e_cnt[i], i)
		else:
			max_e[1] = (v_e_cnt[i], i)
	if max_o[1][0] < v_o_cnt[i]:
		if max_o[0][0] < v_o_cnt[i]:
			max_o[1] = max_o[0]
			max_o[0] = (v_o_cnt[i], i)
		else:
			max_o[1] = (v_o_cnt[i], i)

ans = n - max_e[0][0] - max_o[0][0]
if max_e[0][1] == max_o[0][1]:
	ans = n - max(max_e[0][0] + max_o[1][0], max_e[1][0] + max_o[0][0])

print(ans)


Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: A sequence a_1,a_2,... ,a_n is said to be /\/\/\/ when the following conditions are satisfied:    * For each i = 1,2,..., n-2, a_i = a_{i+2}.   * Exactly two different numbers appear in the sequence.  You are given a sequence v_1,v_2,...,v_n whose length is even. We would like to make this sequence /\/\/\/ by replacing some of its elements. Find the minimum number of elements that needs to be replaced.

Submission attempts (in order):
n=int(input())
a=list(map(int, input().split()))

b=[a[i] for i in range(0,n,2)]
c=[a[i] for i in range(1,n,2)]
from collections import Counter
xb=list(Counter(b).items())
xc=list(Counter(c).items())
xb=sorted(xb, key=lambda x:-x[1])
xc=sorted(xc, key=lambda x:-x[1])
ans=[]
print(xb,xc)
if xb[0][0]==xc[0][0]:
    print(len(xc),len(xb))
    if len(xc)>1:
        ans.append(n//2-xb[0][1]-(-n//2)-xc[1][1])
    if len(xb)>1:
        ans.append(n//2-xb[1][1]-(-n//2)-xc[0][1])
    if len(xc)==1 and len(xb)==1:
        ans.append(n//2)
else:
    ans.append(n//2-xb[0][1]-(-n//2)-xc[0][1])
print(min(ans))

n=int(input())
a=list(map(int, input().split()))

b=[a[i] for i in range(0,n,2)]
c=[a[i] for i in range(1,n,2)]
from collections import Counter
xb=list(Counter(b).items())
xc=list(Counter(c).items())
xb=sorted(xb, key=lambda x:-x[1])
xc=sorted(xc, key=lambda x:-x[1])
ans=[]
if xb[0][0]==xc[0][0]:
    if len(xc)>1:
        ans.append(n//2-xb[0][1]-(-n//2)-xc[1][1])
    if len(xb)>1:
        ans.append(n//2-xb[1][1]-(-n//2)-xc[0][1])
    if len(xc)==1 and len(xb)==1:
        ans.append(n//2)
else:
    ans.append(n//2-xb[0][1]-(-n//2)-xc[0][1])
print(min(ans))

Verdicts: Wrong Answer

Accepted
Problem: A sequence a_1,a_2,... ,a_n is said to be /\/\/\/ when the following conditions are satisfied:    * For each i = 1,2,..., n-2, a_i = a_{i+2}.   * Exactly two different numbers appear in the sequence.  You are given a sequence v_1,v_2,...,v_n whose length is even. We would like to make this sequence /\/\/\/ by replacing some of its elements. Find the minimum number of elements that needs to be replaced.

Submission attempts (in order):
import collections

n = int(input())
v = list(map(int,input().split()))

v1 = v[::2]
v2 = v[1::2]

c1 = collections.Counter(v1)
c2 = collections.Counter(v2)

if v1 == v2 and len(c1.most_common()) == 1
    print(len(v1))
elif c1.most_common()[0][0] != c2.most_common()[0][0]:
    print(len(v1) - c1.most_common()[0][1] + len(v2) - c2.most_common()[0][1])
else:
    if c1.most_common()[1][1] < c2.most_common()[1][1]:
        print(len(v1) - c1.most_common()[0][1] + len(v2) - c2.most_common()[1][1])
    else:
        print(len(v1) - c1.most_common()[1][1] + len(v2) - c2.most_common()[0][1])

import collections

n = int(input())
v = list(map(int,input().split()))

v1 = v[::2]
v2 = v[1::2]

c1 = collections.Counter(v1)
c2 = collections.Counter(v2)

if (v1 == v2 and len(c1.most_common()) == 1):
    print(len(v1))
elif c1.most_common()[0][0] != c2.most_common()[0][0]:
    print(len(v1) - c1.most_common()[0][1] + len(v2) - c2.most_common()[0][1])
else:
    if c1.most_common()[1][1] < c2.most_common()[1][1]:
        print(len(v1) - c1.most_common()[0][1] + len(v2) - c2.most_common()[1][1])
    else:
        print(len(v1) - c1.most_common()[1][1] + len(v2) - c2.most_common()[0][1])

Verdicts: Runtime Error

Accepted
Problem: You are given a string s of length n. Does a tree with n vertices that satisfies the following conditions exist?    * The vertices are numbered 1,2,..., n.   * The edges are numbered 1,2,..., n-1, and Edge i connects Vertex u_i and v_i.   * If the i-th character in s is `1`, we can have a connected component of size i by removing one edge from the tree.   * If the i-th character in s is `0`, we cannot have a connected component of size i by removing any one edge from the tree.  If such a tree exists, construct one such tree.

Submission attempts (in order):
input()
print(input().split().index('1')+1)

s = input()
n = len(s)
if s[0] == '0':
    print(-1)
    exit(0)
if s[-1] == '1':
    print(-1)
    exit(0)
for i in range((n - 1) // 2):
    if s[i] != s[n - i - 2]:
        print(-1)
        exit(0)
p = 1
t = 2
i = n - 2
while i >= 0:
    print(p, t)
    if s[i] == '1':
        p = t
    t += 1
    i -= 1

Verdicts: Runtime Error

Accepted
Problem: You are given a string s of length n. Does a tree with n vertices that satisfies the following conditions exist?    * The vertices are numbered 1,2,..., n.   * The edges are numbered 1,2,..., n-1, and Edge i connects Vertex u_i and v_i.   * If the i-th character in s is `1`, we can have a connected component of size i by removing one edge from the tree.   * If the i-th character in s is `0`, we cannot have a connected component of size i by removing any one edge from the tree.  If such a tree exists, construct one such tree.

Submission attempts (in order):
s = input()

def print_index(x,y):
    if y > len(s):
        return
    print(x,y)

def solve(s,index):
    if not s:
        return
    if s[0]=="1":
        print_index(index,index+1)
        return solve(s[1:],index+1)
    else:
        print_index(index,index+1)
        print_index(index,index+2)
        return solve(s[1:],index+1)


(solve(s,1))

import bisect
s = input()
if s[-1] == "1" or s[0] == "0":
    print(-1)
    exit()

for i in range((len(s) - 1) // 2):
    
    if s[i] != s[len(s) - i -2]:
        print(-1)
        exit()

sd = s[:-1] + '1'
plist = [i for i, v in enumerate(sd) if v == '1']
# print(plist)
for i,v in enumerate(s[:-1]):
    r = bisect.bisect(plist,i)
    print(i+1,plist[r] + 1)



Verdicts: Runtime Error

Accepted
Problem: You are given a string s of length n. Does a tree with n vertices that satisfies the following conditions exist?    * The vertices are numbered 1,2,..., n.   * The edges are numbered 1,2,..., n-1, and Edge i connects Vertex u_i and v_i.   * If the i-th character in s is `1`, we can have a connected component of size i by removing one edge from the tree.   * If the i-th character in s is `0`, we cannot have a connected component of size i by removing any one edge from the tree.  If such a tree exists, construct one such tree.

Submission attempts (in order):
s = input()
l = len(s)

if s[0] != '1' or s[-2] != '1' or s[-1] != '0':
  print('-1')
if s[:-1] != s[:-1][::-1]:
  print('-1')


e = [list(range(2, l+1))] + [[] for _ in range(l-1)]
now = 0
h = (l-1) // 2
for i in range(h, 0, -1):
  c = s[i]
  if c == '0':
    continue
  
  nowl = len(e[now])
  e[l-i-1] = e[now][-i:]
  e[now] = e[now][:nowl-i]
  now = l-i-1

for i, arr in enumerate(e):
  for a in arr:
    print(i+1, a)

s = input()
l = len(s)

if s[0] != '1' or s[-2] != '1' or s[-1] != '0':
  print('-1')
  exit()
if s[:-1] != s[:-1][::-1]:
  print('-1')
  exit()


e = [l] + [-1] * (l-1)
now = 0
h = (l-1) // 2
for i in range(h, 0, -1):
  c = s[i]
  if c == '0':
    continue
  
  e[now] = l - i
  e[l-i-1] = l
  now = l-i-1

for i, a in enumerate(e):
  for j in range(i+2, a+1):
    print(i+1, j)

Verdicts: Wrong Answer

Accepted
Problem: You are given a string s of length n. Does a tree with n vertices that satisfies the following conditions exist?    * The vertices are numbered 1,2,..., n.   * The edges are numbered 1,2,..., n-1, and Edge i connects Vertex u_i and v_i.   * If the i-th character in s is `1`, we can have a connected component of size i by removing one edge from the tree.   * If the i-th character in s is `0`, we cannot have a connected component of size i by removing any one edge from the tree.  If such a tree exists, construct one such tree.

Submission attempts (in order):
n=input()
n='0'+n
l=len(n)
flag=0
if n!=n[::-1]:
    flag=1
if n[1]=='0':
    flag=1
if flag==0:
    print(1,2)
    c=1
    for i in range(1,l-2):
        if n[i]=='1':
            print(i+1,i+2)
            c+=1
        else:
            print(c,i+2)

n=input()
n='0'+n
l=len(n)
flag=0
if n!=n[::-1]:
    flag=1
if n[1]=='0':
    flag=1
if flag==0:
    print(1,2)
    c=1
    for i in range(1,l-2):
        if n[i]=='1':
            print(i+1,i+2)
            c=i+1
        else:
            print(c,i+2)
else:
    print(-1)

Verdicts: Wrong Answer

Accepted
Problem: You are given a string s of length n. Does a tree with n vertices that satisfies the following conditions exist?    * The vertices are numbered 1,2,..., n.   * The edges are numbered 1,2,..., n-1, and Edge i connects Vertex u_i and v_i.   * If the i-th character in s is `1`, we can have a connected component of size i by removing one edge from the tree.   * If the i-th character in s is `0`, we cannot have a connected component of size i by removing any one edge from the tree.  If such a tree exists, construct one such tree.

Submission attempts (in order):
# coding: utf-8
# Your code here!

ss=input()
ans=0

if ss[-1]==1:
    ans=-1
s=ss[:-1]
#print(s)
gans=[]

c=1
for i in range(len(s)):
    if i==0 and s[i]=="0":
        ans=-1
        break
    
    if s[i]=="1":
        gans.append([c, i+2])
        c=i+2
    else:
        gans.append([i+2,c])


if ans==-1:
    print(ans)
else:
    for i in gans:
        print(*i)

# coding: utf-8
# Your code here!

ss=input()
ans=0

if ss[-1]=="1":
    ans=-1
s=ss[:-1]
#print(s)
gans=[]

c=1
for i in range(len(s)):
    if i==0 and s[i]=="0":
        ans=-1
        break
    if s[i] != s[len(s)-i-1]:
        ans=-1
        break
    
    if s[i]=="1":
        gans.append([c, i+2])
        c=i+2
    else:
        gans.append([i+2,c])


if ans==-1:
    print(ans)
else:
    for i in gans:
        print(*i)

Verdicts: Wrong Answer

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
s=list(map(int,input().split())
s.sort()
print(max(10*s[0]+s[1]+s[2],s[0]+s[1]*10+s[2],s[0]+s[1]+s[2]*10))

A,B,C=sorted(map(int.input.split()))
print(A+B+C*10)

A,B,C=map(int,input().split())
D=A+B
print(D+C)

A,B,C=sorted(map(int,input.split()))
print(A+B+C*10)

A,B,C=sorted(map(int,input().split()))
print(A+B+C*10)

Verdicts: Runtime Error

Runtime Error

Wrong Answer

Runtime Error

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
a,b,c=sorted(map(int,input()))
print(10*c+a+b)


a,b,c=sorted(map(int,input().split()))
print(10*c+a+b)


Verdicts: Runtime Error

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
import math
import sympy
import numpy as np

def p(n,r):
    return int(math.factorial(n)/math.factorial(n-r))
def c(n,r):
    return int(p(n,r)/math.factorial(r))

n, m = map(int, input().split())
dic = sympy.factorint(m)
print(dic)
ans = [c(i+n-1,i) % (10**9+7) for i in dic.values()]
print(np.prod(ans) % (10**9+7))

a = sorted(list(map(int, input().split())))[::-1]
print(int(str(a[0]) + str(a[1])) + a[2])

Verdicts: Runtime Error

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
abc = list(map(int,input().split()))
abc.sort
print(abc[0] + (abc[2]*10 + abc[1]))


abc = list(map(int,input().split()))
abc.sort()
print(abc[0] + (abc[2]*10 + abc[1]))


Verdicts: Wrong Answer

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
a=list(map(int,input().split()))
a.sort()
print(int (str(a[0])+str(a[1])) +a[2])

a=list(map(int,input().split()))
a.sort()
print(int (str(a[2])+str(a[1])) +a[0])


Verdicts: Wrong Answer

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
n, m, x, y = [int(i) for i in input().split(" ")]
x_range = [int(i) for i in input().split(" ")]
y_range = [int(i) for i in input().split(" ")]
war = True
for z in range(x, y):
    if x < z <= y and max(x_range) < z <= min(y_range[:m]):
        war = False
print("War" if war else "No War")


input_data = [int(i) for i in input().split(" ")]

ans = 0
for k1, v1 in enumerate(input_data):
    for k2, v2 in enumerate(input_data):
        for k3, v3 in enumerate(input_data):
            if k1 == k2 or k2 == k3 or k3 == k1:
                continue
            kou1 = int(v1 + v2)
            if ans < kou1 + v3:
                ans = kou1 + v3
print(ans)



s = input()
t = input()

[globals().update({'s': s.translate(str.maketrans({s[i]: t[i], t[i]: s[i]}))}) for i in range(len(s))]

print("Yes" if s == t else "No")


input_data = [int(i) for i in input().split(" ")]

ans = 0
for k1, v1 in enumerate(input_data):
    for k2, v2 in enumerate(input_data):
        for k3, v3 in enumerate(input_data):
            if k1 == k2 or k2 == k3 or k3 == k1:
                continue
            kou1 = int(str(v1) + str(v2))
            kou2 = v3
            if ans < kou1 + kou2:
                ans = kou1 + v3
print(ans)


Verdicts: Runtime Error

Wrong Answer

Runtime Error

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
A, B, C = map(int, input().split())
m = max(A, B, C)
print(m * 9 + sum(A, B, C))

A, B, C = map(int, input().split())
m = max(A, B, C)
print(m * 9 + sum((A, B, C)))

Verdicts: Runtime Error

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
s1 = input()
t1 = input()

s = list(s1)
t = list(t1)

flag = 0
for i in range(len(s)):
    for j in range(len(s)):
        if s[i] == s[j]:
            if t[i] == t[j]:
                a = 1
            else:
                print("No")
                flag = 1
                break
        if flag == 1:
            break

        if t[i] == t[j]:
            if s[i] == s[j]:
                a = 1
            else:
                print("No")
                flag = 1
                break
        if flag == 1:
            break
    if flag == 1:
        break
if flag == 0:
    print("Yes")


d = input().split()

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

int e = 0

e = a*10+b+c

if e < b*10+a+c:
    e = b*10+a+c
    if e < c*10+a+b:
        e = c*10+a+b

if e < c*10+a+b:
    e= c*10+a+b
    if e < b*10+a+c:
        e = b*10+a+c

print(e)


d = input().split()

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

e = 0

e = a*10+b+c

if e < b*10+a+c:
    e = b*10+a+c
    if e < c*10+a+b:
        e = c*10+a+b

if e < c*10+a+b:
    e= c*10+a+b
    if e < b*10+a+c:
        e = b*10+a+c

print(e)


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
A = [int(i) for i in input().split()]
A.sort()
print(10*A[0] + A[1] + A[2])

A = [str(i) for i in input().split()]
A.sort()
A.insert(2, '+')
print(eval(''.join(A)))

A = [int(i) for i in input().split()]
A.sort(reverse=True)
print(10*A[0] + A[1] + A[2])

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
a,b,c = sorted(list(map(int, input().split())))
print(a*10+b+c)

a,b,c = *sorted(list(map(int, input().split())))
print(a*10+b+c)

a,b,c = sorted(list(map(int, input().split())))
print(c*10+b+a)

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
s = sorted(map(int, input().split()))

print(s[2] * 10 + s[0] + s[0])


s = sorted(map(int, input().split()))

print(s[2] * 10 + s[0] + s[1])


Verdicts: Wrong Answer

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
l = list(map(int, input.split()))
print(sum(l)+max(l)*9)

l = list(map(int, input().split()))
print(sum(l)+max(l)*9)

Verdicts: Runtime Error

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
s  = list(str(input()))
t  = list(str(input()))
s.sort()
t.sort()

for i in range(len(s)):
 
    if s[i] != t[i]:
 
        c1 = s[i]
        c2 = t[i]
 
        for j in range(len(s)):
            if s[j] == c1:
                s[j] = c2
            elif s[j] == c2:
                s[j] = c1

if "".join(s) == "".join(t) :
    print("Yes")        
else :
    print("No")

s  = list(str(input()))
t  = list(str(input()))

sd = {}
td = {}

for k in range(ord('a'),ord('z')+1):   
    sd[chr(k)] = 0
    td[chr(k)] = 0

for i in range(len(s)) :
    if s[i] in sd :
        sd[s[i]] = sd[s[i]] + 1

    if t[i] in td :
        td[t[i]] = td[t[i]] + 1
""" 
for k in range(ord('a'),ord('z')+1):   
    print(str(chr(k)) + ":",end="")
    if chr(k) in sd :
        print(str(sd[chr(k)]) + " ",end="")
    else:
        print("0 ",end="")
print()
for k in range(ord('a'),ord('z')+1):   
    print(str(chr(k)) + ":",end="")
    if chr(k) in td :
        print(str(td[chr(k)]) + " ",end="")
    else:
        print("0 ",end="")
print() """

ta = []
sa = []
for k in range(ord('a'),ord('z')+1):
    if td[chr(k)] != sd[chr(k)] : 
        if td[chr(k)] > 0 :
            ta.append(td[chr(k)])
        if sd[chr(k)] > 0 :    
            sa.append(sd[chr(k)])
#print(ta)
#print(sa)

ta.sort()
sa.sort()

if ta == sa :
    print("Yes")
else :
    print("No")

l = list(map(int,input().split()))
l.sort(reverse=True)
print(l[0]*10+l[1]+l[2])

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
A,B,C=input().split()

a=int(A)
b=int(B)
c=int(C)

if a>=b:
  if a>=c:
    x=a
    if b>=c:
      y=b
      z=c
      else:
        y=c
        z=b
    else:
      x=c
      y=a
      z=b
else:
  if b>=c:
    x=b
    if a>=c:
      y=a
      z=c
      else:
        y=c
        z=a
    else:
      x=c
      y=b
      z=a

n==x*100+y*10+z
print(n)

A,B,C=input().split()

a=int(A)
b=int(B)
c=int(C)

if a>=b:
  if a>=c:
    x=a
    if b>=c:
      y=b
      z=c
    else:
        y=c
        z=b
  else:
      x=c
      y=a
      z=b
else:
  if b>=c:
    x=b
    if a>=c:
      y=a
      z=c
    else:
        y=c
        z=a
  else:
      x=c
      y=b
      z=a

n=x*10+y+z
print(n)

Verdicts: Runtime Error

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
A,B,C = map(int, input().split())
r = max(A,B,C)*10 + B +C
print(int(r))

A,B,C = map(int, input().split())
r = max(A,B,C)*10 + B +C
print(r)

A,B,C = map(int, input().split())
r = max(A,B,C)*9 + sum(A, B, C)
print(int(r))

A,B,C = map(int, input().split())
r = max(A,B,C)*9 + A+B+C
print(int(r))

Verdicts: Wrong Answer

Wrong Answer

Runtime Error

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
A, B, C = map(int, input().split())
if 10 * A + B < 10 * C + B:
  print(10 * C + B)
else:
  print(10 * A + B)

A, B, C = map(int, input().split())
if 10 * A + B < 10 * C + B:
  print(10 * B + C)
else:
  print(10 * A + B)

A, B, C = sorted(map(int, input().split()))
print(10 * C + A + B)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
a=list(input().split())
a=sorted(a)
print(int(a[2])+int(a[0]+a[1]))

a,b,c=map(int,input().split())
print(a+int(b+c))

a=list(input().split()))
a=sorted(a)
print(int(a[2])+int(a[0]+a[1])))

a=list(input().split())
a=sorted(a)
print(int(a[2])+int(a[0]+a[1])))

a=list(input().split())
a=sorted(a)
print(int(a[0])+int(a[2]+a[1]))

Verdicts: Wrong Answer

Wrong Answer

Runtime Error

Runtime Error

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
a,b,c = sorted (map(int,input().split())
print(10*c+b+a)

print(eval('+'.join(sorted(input()))+"*10"))

Verdicts: Runtime Error

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
def main():
	l = map(int, input().split())
	A=l[0]
	B=l[1]
	C=l[2]

	l_max=max(A,B,C)
	l_min=min(A,B,C)
	l_mid=(A+B+C)-(l_max+l_min)

	ans=10*l_max+l_mid+l_min
	print(ans)
    
main()

def main():
	A, B, C = [int(_) for _ in input().split()]

	l_max=max(A,B,C)
	l_min=min(A,B,C)
	l_mid=(A+B+C)-(l_max+l_min)

	ans=10*l_max+l_mid+l_min
	print(ans)
    
main()

Verdicts: Runtime Error

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
n, m, X, Y = map(int, input().split())
x = [int(i) for i in input().split()]
y = [int(i) for i in input().split()]

x.append(X)
y.append(Y)

if max(x) < min(y):
    print("No War")
else :
    print("War")

a, b, c = map(int, input().split())
array = [a, b, c]
array.sort()
print(array[-1] * 10 + array[0] + array[1])

Verdicts: Runtime Error

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
x=list(map(int, input().split()))
print(max(x[0]*10+x[1], x[1]*10+x[2]))

x=list(map(int, input().split()))
print(max(x[0]*10+x[1]+x[2], x[0]+x[1]*10+x[2], x[0]+x[1]+x[2]*10))

Verdicts: Wrong Answer

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
a=list(map(int,input().split()))
sorted(a)
print(10*a[2]+a[1]+a[0])

a=list(map(int,input().split()))
a=sorted(a)
print(10*a[2]+a[1]+a[0])

Verdicts: Wrong Answer

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
def factorial(n):
	fact = 1
	while n > 0:
		fact *= n
		n -= 1
	return fact
	
def combination(n, r):
    return factorial(n) // (factorial(n - r) * factorial(r))

n, m = map(int, input().split())
n_def = n
natural = list(range(2,320))
index = 0
while index < len(natural):
	for number in natural:
		if number % natural[index] == 0 and number / natural[index] != 1:
			natural.remove(number)
	index += 1
prime = natural

prime_division = {}
index = 0
number_prime = 0
while prime[index] <= m:
	if m % prime[index] == 0:
		m /= prime[index]
		number_prime += 1
		continue		
	else:
		prime_division[prime[index]] = number_prime
		number_prime = 0
		index += 1
else:
	prime_division[prime[index]] = number_prime

list_division = list(prime_division.values())
ans = 1
for i in list_division:
	ans *= combination(i+n-1,n-1)
print(int(ans%(10**9 + 7)))

a,b,c = map(int, input().split())
print(9*max(a,b,c) + a+b+c)

Verdicts: Runtime Error

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
ABC = [int(x) for x in input().split()]
ABC.sort()
answer = ABC[0]*10 + sum(ABC[1:])
print(answer)

ABC = [int(x) for x in input().split()]
ABC.sort()
answer = ABC[-1]*10 + sum(ABC[:2])
print(answer)

Verdicts: Wrong Answer

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
n = list(map(int,input().split())).sort()
print(n[2]*10+n[1]+n[0])


n = list(map(int,input(),split()))
n.sort()
n.reverse()
print(n[0]*10+n[1]+n[2])

s = input()
t = input()
for i in range(len(s)-2):
  if (s[i] == s[i+1]) != (t[i] == t[i+1]):
    print("No")
    exit()
print("Yes")

def factorize(n):
    fct = []  
    b, e = 2, 0  
    while b * b <= n:
        while n % b == 0:
            n = n // b
            e = e + 1
        if e > 0:
            fct.append((b, e))
        b, e = b + 1, 0
    if n > 1:
        fct.append((n, 1))
    return fct

  
def cmb(n, r, mod):
    if ( r<0 or r>n ):
        return 0
    r = min(r, n-r)
    return g1[n] * g2[r] * g2[n-r] % mod
  
  
N,M = map(int, input().split())
m_factorized = factorize(M)
mod = 10 ** 9 + 7
g1 = [1, 1] 
g2 = [1, 1] 
inverse = [0, 1] 計算用テーブル
ans = 1
for i in range( 2, 2**N + 1 ):
  g1.append( ( g1[-1] * i ) % mod )
  inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
  g2.append( (g2[-1] * inverse[-1]) % mod )
    
    
for i in m_factorized:
  k = i[1] 
  ans *= cmb(N-1+k,k,mod)
  ans %= mod
print(ans)
  

n = list(map(int,input().split()))
n.sort()
print(n[2]*10+n[1]+n[0])


Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
l = list(map(int,input().split())).sort
print(l[2]*10 + l[1] + l[0])

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

print(max(a)*9 + sum(a))

Verdicts: Runtime Error

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
a=list(map(int,input().split()))
a.sort()
print(a[0]*10+a[1]+a[2])

a=list(map(int,input().split()))
a.sort()
print(a[2]*10+a[1]+a[0])

Verdicts: Wrong Answer

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
,b,c = map(int, input().split())

ans = []

ans.append(10*a+b+c)
ans.append(10*b+a+c)
ans.append(10*c+b+a)

print(max(ans))

a,b,c = map(int, input().split())

ans = []

ans.append(10*a+b+c)
ans.append(10*b+c+a)
ans.append(10*c+a+b)

print(max(ans))

Verdicts: Runtime Error

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
A,B,C = list(map(int,input()))
if A >= B and B >= C:
  print(A*10 + B+C)
elif B >= C and C >=A:
  print(B*10 + C+A)
elif C >= A and A >= B:
  print(C*10 + A+B)

A,B,C = list(map(int,input().split()))
if A >= B and B >= C:
  print(A*10 + B+C)
elif B >= C and C >=A:
  print(B*10 + C+A)
elif C >= A and A >= B:
  print(C*10 + A+B)
elif A >= B and C >= B:
  print(A*10 + B+C)
elif B >= A and A >= C:
  print(B*10 + A+C)
elif C >= A and B >= A:
  print(C*10 + A+B)

Verdicts: Runtime Error

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
a,b,c = sorted(map(int,input().split()))
print(10*c+b+c)

a,b,c = sorted(map(int,input().split()))
print(10*c+b+a)

Verdicts: Wrong Answer

Accepted
Problem: You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:    * There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a `+` printed on it.   * The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)   * Then, the amount of the allowance will be equal to the resulting value of the formula.  Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Submission attempts (in order):
a=list(map(int,input().split()))
sorted(a)
print(a[0]+a[1]*a[2])


a=list(map(int,input().split()))
a=sorted(a)
print(a[-1]*10+a[1]+a[0])

Verdicts: Wrong Answer

Accepted