ZhenlongDai/ACPR huggingface dataset:
Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = list(input())
p = S.count('○')
print(700+2*100)

Failing test case input:
nnp

Expected output:
700


Actual output:
900


Fixed submission (verdict: Accepted):
S = list(input())
p = S.count('o')
print(700 + p*100)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
print(700 + input().count("o"))

Failing test case input:
xno

Expected output:
800


Actual output:
701


Fixed submission (verdict: Accepted):
print(700 + input().count("o") * 100)

Problem: p03369
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
print(700+input().count("o"))

Failing test case input:
qop

Expected output:
800


Actual output:
701


Fixed submission (verdict: Accepted):
print(700+input().count("o")*100)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S=str(input())
X=S.count("○")
print(700+100*int(X))


Failing test case input:
ozm

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):
s=str(input())
x=s.count('o')
print(700+100*x)

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


a = input()
count = sum([i for i in range(3) if a[i] == "o"])
print(700 + (100*count))

Failing test case input:
ooq

Expected output:
900


Actual output:
800


Fixed submission (verdict: Accepted):


count = sum([1 for a in input() if a == "o"])
print(700 + (100*count))

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
if __name__ == '__main__':
    s = input()
    t = list(s).count('〇')
    v = 700 + 100 * t
    print(v)

Failing test case input:
mqo

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):
if __name__ == '__main__':
    s = input()
    t = list(s).count('o')
    v = 700 + 100 * t
    print(v)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = input()
cnt = 0
for i in range(3):
  if S[i] == "o":
    cnt += 1
print(700+cnt)

Failing test case input:
nxo

Expected output:
800


Actual output:
701


Fixed submission (verdict: Accepted):
S = input()
cnt = 0
for i in range(3):
  if S[i] == "o":
    cnt += 1
print(700+cnt*100)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
lista = list(input())
lista2 = lista.count('x')
lista3 = 700 + (lista2 * 100 )
print(lista3)

Failing test case input:
xw{

Expected output:
700


Actual output:
800


Fixed submission (verdict: Accepted):
lista = list(input())
lista2 = lista.count('o')
lista3 = 700 + (lista2 * 100 )
print(lista3)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
list = list(input())
print(list.count('o')*100)

Failing test case input:
pk|

Expected output:
700


Actual output:
0


Fixed submission (verdict: Accepted):
list = list(input())
print(list.count('o')*100+700)

Problem: p03369
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a=input()
t=0
for i in range(3):
  if a[i]=="o":
    t+=1
print(500+t*100)

Failing test case input:
ywz

Expected output:
700


Actual output:
500


Fixed submission (verdict: Accepted):
a=input()
t=0
for i in range(3):
  if a[i]=="o":
    t+=1
print(700+t*100)
Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = input()

Ramen = 700
print(S)

if S[0] == 'o':
    Ramen += 100
if S[1] == 'o':
    Ramen += 100
if S[2] == 'o':
    Ramen += 100

print(Ramen)

Failing test case input:
omz

Expected output:
800


Actual output:
omz
800


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

Ramen = 700

if S[0] == 'o':
    Ramen += 100
if S[1] == 'o':
    Ramen += 100
if S[2] == 'o':
    Ramen += 100

print(Ramen)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S=str(input())
print(700+100*S.count("○"))


Failing test case input:
ppo

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):
s=str(input())
x=s.count('o')
print(700+100*x)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
toppings = list(input())
ans = 700
for i in toppings:
  if i == "○":
    ans += 100
print(ans)

Failing test case input:
oor

Expected output:
900


Actual output:
700


Fixed submission (verdict: Accepted):
toppings = list(input())
ans = 700
for i in toppings:
  if i == "o":
    ans += 100
print(ans)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = input()

Ramen = 700

if S[0] == '○':
    Ramen += 100
if S[1] == '○':
    Ramen += 100
if S[2] == '○':
    Ramen += 100

print(Ramen)

Failing test case input:
qmo

Expected output:
800


Actual output:
700


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

Ramen = 700

if S[0] == 'o':
    Ramen += 100
if S[1] == 'o':
    Ramen += 100
if S[2] == 'o':
    Ramen += 100

print(Ramen)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
data=input().rstrip().split()
data=list(data)
ans=700
for i in data:
  if "o" ==i:
    ans+=100
print(ans)

Failing test case input:
oox

Expected output:
900


Actual output:
700


Fixed submission (verdict: Accepted):
data=input().rstrip()
data=list(data)
ans=700
for i in data:
  if "o"==i:
    ans+=100
print(ans)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = list(input())
price = 700
for i in range(len(S)):
    if S[i] == "○":
        price += 100
print(price)

Failing test case input:
nxo

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):
S = list(input())
price = 700
for i in range(len(S)):
    if S[i] == "o":
        price += 100
print(price)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = input()
cnt = 0
for i in s:
    if s == "o":
        cnt += 1
print(700 + 100 * cnt)

Failing test case input:
{ko

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):
s = input()
cnt = 0
for i in s:
    if i == "o":
        cnt += 1
print(700 + 100 * cnt)
Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = input()
value = 700
if(s[0]== '○'):
    value += 100
if(s[1]== '○'):
    value += 100
if(s[2]== '○'):
    value += 100
print(value)

Failing test case input:
qpo

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):
s = input()
value = 700
if(s[0]== 'o'):
    value += 100
if(s[1]== 'o'):
    value += 100
if(s[2]== 'o'):
    value += 100
print(value)

Problem: p03369
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import collections

a=list(input())
print(a)
print(a.count("o"))

A = collections.Counter(a)
x = (A["o"])

print(700+100*x)

Failing test case input:
xzv

Expected output:
700


Actual output:
['x', 'z', 'v']
0
700


Fixed submission (verdict: Accepted):
import collections

a=list(input())
A = collections.Counter(a)
x = (A["o"])

print(700+100*x)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s=input()
print(700+s.count("o"))


Failing test case input:
ooq

Expected output:
900


Actual output:
702


Fixed submission (verdict: Accepted):
s=input()
print(700+100*(s.count("o")))

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

s = sys.stdin.readline()

print(700 + s.count('c') * 100)


Failing test case input:
ol{

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):
import sys
 
s = sys.stdin.readline()
 
print(700 + s.count('o') * 100)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = input().split(",")
topping = S.count("o")
print(700+topping)

Failing test case input:
xoo

Expected output:
900


Actual output:
700


Fixed submission (verdict: Accepted):
S = input()
topping = S.count("o")
ans = 700 + topping*100
print(ans)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
print(700 + input().count("○") * 100)

Failing test case input:
xno

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):
print(700 + input().count("o") * 100)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x = input().count("○")

print(700 + 100 * x)

Failing test case input:
soo

Expected output:
900


Actual output:
700


Fixed submission (verdict: Accepted):
x = input().count("o")

print(700 + 100 * x)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
money = 700

tp = input()

for s in tp:
  if(s == "○"):
    money += 100

print(money)

Failing test case input:
ooq

Expected output:
900


Actual output:
700


Fixed submission (verdict: Accepted):
money = 700

tp = input()

for s in tp:
  if(s == "o"):
    money += 100

print(money)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
t = input()

ans=700
for x in t:
  if x=='o':
    ans+=100


Failing test case input:
xwz

Expected output:
700


Actual output:

Fixed submission (verdict: Accepted):
t = input()

ans=700
for x in t:
  if x=='o':
    ans+=100
print(ans)
Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
print(100*input().count('○'))

Failing test case input:
sqo

Expected output:
800


Actual output:
0


Fixed submission (verdict: Accepted):
print(700+100*input().count('o'))

Problem: p03369
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
s=input()
print(700+100*s.count('〇'))

Failing test case input:
oor

Expected output:
900


Actual output:
700


Fixed submission (verdict: Accepted):
print(700 + 100 * input().count('o'))

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
print(700+list(input()).count('○')*100)

Failing test case input:
oox

Expected output:
900


Actual output:
700


Fixed submission (verdict: Accepted):
print(700+list(input()).count('o')*100)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s=str(input())
x=s.count('○')
print(700+100*x)


Failing test case input:
qpo

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):
s=str(input())
x=s.count('o')
print(700+100*x)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys
s = sys.stdin.readline() 

l = [0,0,0]
for i in range(2):
    if s[i] == "o":
        l[i] = 100
    elif s[i] == "x":
        l[i] = 0
goukei = 700+l[0]+l[1]+l[2]
print(goukei)




Failing test case input:
ppo

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):
import sys
s = sys.stdin.readline() 

l = [0,0,0]
for i in range(3):
    if s[i] == "o":
        l[i] = 100
    elif s[i] == "x":
        l[i] = 0
goukei = 700+l[0]+l[1]+l[2]
print(goukei)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = list(input())

print(700 + s.count('o'))

Failing test case input:
mqo

Expected output:
800


Actual output:
701


Fixed submission (verdict: Accepted):
s = list(input())

print(700 + 100 * s.count('o'))

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
l=list(input())
print(700+l.count("o"))

Failing test case input:
pxo

Expected output:
800


Actual output:
701


Fixed submission (verdict: Accepted):
l=list(input())
print(700+(l.count("o"))*100)

Problem: p03369
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
S = input().strip()
print(700+200*S.count('o'))


Failing test case input:
onq

Expected output:
800


Actual output:
900


Fixed submission (verdict: Accepted):
S = input().strip()
print(700+100*S.count('o'))

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

 
s = "S"
a = s.count('o')
x = 700 + 100 * a
print(x)

Failing test case input:
oor

Expected output:
900


Actual output:
700


Fixed submission (verdict: Accepted):

s = input()
a = s.count('o')
y = 700 + 100 * a
print(y)
Problem: p03369
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
qqq = list(input())
List_R = []
if qqq[0] == "○":
    List_R.append(1)
if qqq[1] == "○":
    List_R.append(1)
if qqq[2] == "○":
    List_R.append(1)
print(700+len(List_R*100))

Failing test case input:
qno

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):
qqq = list(input())
List_R = []
if qqq[0] == "o":
    List_R.append(1)
if qqq[1] == "o":
    List_R.append(1)
if qqq[2] == "o":
    List_R.append(1)
print(700+len(List_R*100))

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
ans = 0
for x in input():
    if x == 'o':
        ans += 100
print(ans)

Failing test case input:
yvx

Expected output:
700


Actual output:
0


Fixed submission (verdict: Accepted):
ans = 0
for x in input():
    if x == 'o':
        ans += 100
print(700+ans)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = str(input())
n = s.count('○')
print(700 + 100*n)

Failing test case input:
pxo

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):
s = input()
n = s.count('o')
print(700 + 100*n)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = input()
b = 0
if a[0]=="o":
  b = b+100
else:
  b = b
if a[1]=="o":
  b = b+100
else:
  b = b
if a[2]=="o":
  b = b + 100
else:
  b = b
print(b)

Failing test case input:
yzw

Expected output:
700


Actual output:
0


Fixed submission (verdict: Accepted):
a = input()
b = 700
if a[0]=="o":
  b = b+100
else:
  b = b
if a[1]=="o":
  b = b+100
else:
  b = b
if a[2]=="o":
  b = b + 100
else:
  b = b
print(b)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S=str(input())
k = 700
for i in range(3):
  if S[i] == "○":
    k = k + 100
print(k)


Failing test case input:
xpo

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):
S=str(input())
k = 700
for i in range(3):
  if S[i] == 'o':
    k = k + 100
print(k)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = input()
print(700+S.count("○")*100)

Failing test case input:
opp

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):
print(700 + input().count("o") * 100)

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


base = 700
output = base

s = input()
for i in range(3):
    if s[i] == "○":
        output += 100
    else:
        pass

print(output)


Failing test case input:
oxn

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):


base = 700
output = base

s = input()
for i in range(3):
    if s[i] == "o":
        output += 100

print(output)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = input()
print(700+s.count("o"))

Failing test case input:
onp

Expected output:
800


Actual output:
701


Fixed submission (verdict: Accepted):
s = input()
print(700 + s.count("o")*100)
Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
l = input()
ans = 0
for i in l:
    if i=="o":
        ans+=1

print(ans)

Failing test case input:
npm

Expected output:
700


Actual output:
0


Fixed submission (verdict: Accepted):
l = input()
ans = 0
for i in l:
    if i=="o":
        ans+=1

print(ans * 100 + 700)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = input()
Ss = [S[0],S[1],S[2]]
Ss_extract = [x for x in Ss if x == "o"]
print(len(Ss_extract))

Failing test case input:
vzy

Expected output:
700


Actual output:
0


Fixed submission (verdict: Accepted):
S = input()
Ss = [S[0],S[1],S[2]]
Ss_extract = [x for x in Ss if x == "o"]
print(700 + len(Ss_extract)*100)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=input()
print(a.count("o"))

Failing test case input:
pno

Expected output:
800


Actual output:
1


Fixed submission (verdict: Accepted):
a=input()
print(700+100*int(a.count("o")))

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = input()
print(700 + 100 * S.count('x'))

Failing test case input:
omz

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):
S = input()
print(700 + 100 * int(S.count("o")))

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = input()
print(700+2*a.count("o"))

Failing test case input:
omz

Expected output:
800


Actual output:
702


Fixed submission (verdict: Accepted):
a = input()
print(700+100*a.count("o"))

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s=input()
 
ct=0
for i in range(0,len(s)):
    if "o" in s:
        ct=ct+1
if(ct>0):
  f=700+100*ct
else:
  f=700
print(f)  
  
 

Failing test case input:
opo

Expected output:
900


Actual output:
1000


Fixed submission (verdict: Accepted):
s=input()
ct=0
for i in range(0,len(s)):
    
    if(s[i]=="o"): 
        ct=ct+1
if(ct>0):
  f=700+100*ct
else:
  f=700
print(f)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
num = input()

print(700 + num.count("o"))

Failing test case input:
qop

Expected output:
800


Actual output:
701


Fixed submission (verdict: Accepted):
num = input()

print(700 + num.count("o")*100)

Problem: p03369
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
print(input().count('o') * 200 + 700)

Failing test case input:
ppo

Expected output:
800


Actual output:
900


Fixed submission (verdict: Accepted):
print(input().count('o') * 100 + 700)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = input()
print(700+200*a.count("o"))

Failing test case input:
xno

Expected output:
800


Actual output:
900


Fixed submission (verdict: Accepted):
a = input()
print(700+100*a.count("o"))
Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = str(input)
v = 700
if s[0] == 'o':
    v+= 100
if s[1] == 'o':
    v+= 100
if s[2] == 'o':
    v += 100
print(v)

Failing test case input:
nor

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):
s = str(input())
v = 700
if s[0] == 'o':
    v+= 100
if s[1] == 'o':
    v+= 100
if s[2] == 'o':
    v += 100
print(v)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s=input()
ans=s.count("〇")
print(700+(int(ans)*100))

Failing test case input:
oxo

Expected output:
900

Actual output:
700


Fixed submission (verdict: Accepted):
s=input()
ans=s.count("o")
print(700+(int(ans)*100))

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
print(700+list(input().split()).count('o')*100)

Failing test case input:
opp

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):
print(700+input().count('o')*100)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = input()

cnt = 0
for s in S:
  cnt += 1
 
print(700 + 100 * cnt)

Failing test case input:
yxx

Expected output:
700


Actual output:
1000


Fixed submission (verdict: Accepted):
S = input()
 
cnt = 0
for s in S:
	if s == 'o':
		cnt += 1
 
print(700 + 100 * cnt)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = input()
if s.count("o") == 1:
  print(700+100)
elif s.count("o") == 2:
  print(700+200)
else:
  print(700+300)

Failing test case input:
zwx

Expected output:
700


Actual output:
1000


Fixed submission (verdict: Accepted):
s = input()
if s.count("o") == 1:
  print(700+100)
elif s.count("o") == 2:
  print(700+200)
elif s.count("o") == 3:
  print(700+300)
else:
  print(700)

Problem: p03369
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
s = input()
print(700 + s.count("○")*100)

Failing test case input:
opn

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):
s = input()
print(700 + s.count("o")*100)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s=input()
n=s.count('○')
print(700+100*n)


Failing test case input:
onx

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):
s=str(input())
n=s.count('o')
print(700+100*n)

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

s = input()
count = s.count("1")
print(700 + 100 * count)

Failing test case input:
oor

Expected output:
900


Actual output:
700


Fixed submission (verdict: Accepted):

s = input()
count = s.count("o")
print(700 + 100 * count)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = input()
counter = 0
if s[0] == "○":
  counter += 1
if s[1] == "○":
  counter += 1
if s[2] == "○":
  counter += 1
print(700+100*counter)

Failing test case input:
opq

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):
s = input()
counter = 0
if s[0] == 'o':
  counter += 1
if s[1] == 'o':
  counter += 1
if s[2] == 'o':
  counter += 1
print(int(700+counter*100))
Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
print(input().count("o"))

Failing test case input:
qpo

Expected output:
800


Actual output:
1


Fixed submission (verdict: Accepted):
print(700+100*input().count("o"))

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = input()
topping = 0
for i in S:
  topping += 1 if i=='o' else 0
print(700+topping)

Failing test case input:
pop

Expected output:
800


Actual output:
701


Fixed submission (verdict: Accepted):
S = input()
topping = 0
for i in S:
  topping += 1 if i=='o' else 0
print(700+topping*100)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = input()
count = 0
for i in range(3):
    'o' in s[i]
    count += 1
print(700 + count * 100)

Failing test case input:
omz

Expected output:
800


Actual output:
1000


Fixed submission (verdict: Accepted):
s = input()
count = 0
for i in range(3):
    if 'o' in s[i]:
        count += 1
print(700 + count * 100)

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

s = "S"
a = s.count('o')
y = 700 + 100 * a
print(y)

Failing test case input:
ol{

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):

s = input()
a = s.count('o')
y = 700 + 100 * a
print(y)

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

s = "S"
a = s.count('x')
y = 1000 - 100 * a
print(y)

Failing test case input:
xwz

Expected output:
700


Actual output:
1000


Fixed submission (verdict: Accepted):

s = input()
a = s.count('o')
y = 700 + 100 * a
print(y)

Problem: p03369
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = input()

print(700 + s.count("x") * 100)

Failing test case input:
mpo

Expected output:
800


Actual output:
700


Fixed submission (verdict: Accepted):
s = input()

print(700 + s.count("o") * 100)

Problem: p03369
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a=input()
plus=int(a.count("○"))
print(700+100*plus)

Failing test case input:
opo

Expected output:
900


Actual output:
700


Fixed submission (verdict: Accepted):
a = input()
plus = int(a.count("o"))
print(700 + 100 * plus)
Problem: p00024
Buggy submission (Python3, verdict: Wrong Answer):
while(1):
    try:
        n=float(input())
        t=n/9.8
        y=4.9*t**2
        N=(y+5)
        print(N+1)
    except EOFError:
        break

Failing test case input:
73.9111092448129
75.52007039121814

Expected output:
57
60


Actual output:
284.7169423366667
296.9837261170685


Fixed submission (verdict: Accepted):
import math
while(1):
    try:
        n=float(input())
        t=n/9.8
        y=4.9*t**2
        N=(y+5)/5
        print(math.ceil(N))
    except EOFError:
        break

Problem: p00024
Buggy submission (Python3, verdict: Wrong Answer):
while True:
    try:
        v = float(input())
    except:
        break
    print(int(v ** 2 / 98 + 1.5 + 0))

Failing test case input:
50.53281858258607
48.88219396514085

Expected output:
28
26


Actual output:
27
25


Fixed submission (verdict: Accepted):
import math
while True:
    try:
        v = float(input())
    except:
        break
    print(math.floor(v ** 2 / 98 + 2))

Problem: p00024
Buggy submission (Python3, verdict: Wrong Answer):
while True:
    try:
        v = float(input())
    except:
        break
    print(int(v ** 2 / 98 + 1.5 - 0))

Failing test case input:
62.455399191693004
64.49375185423844

Expected output:
41
44


Actual output:
41
43


Fixed submission (verdict: Accepted):
import math
while True:
    try:
        v = float(input())
    except:
        break
    print(math.floor(v ** 2 / 98 + 2))

Problem: p00024
Buggy submission (Python3, verdict: Wrong Answer):
import math
print(math.ceil((math.ceil(4.9*(float(input())/9.8)**2)+5)/5))


Failing test case input:
42.575896692598626
42.26813492288463

Expected output:
20
20


Actual output:
20


Fixed submission (verdict: Accepted):
import math
while 1:
	try: print(math.ceil((math.ceil(4.9*(float(input())/9.8)**2)+5)/5))
	except: break

Problem: p00024
Buggy submission (Python3, verdict: Wrong Answer):
while True:
    try:
        v = float(input())
    except:
        break
    print(int(v ** 2 / 98 + 1.5))

Failing test case input:
49.59887765936179
48.88219396514085

Expected output:
27
26


Actual output:
26
25


Fixed submission (verdict: Accepted):
import math
while True:
    try:
        v = float(input())
    except:
        break
    print(math.floor(v ** 2 / 98 + 2))
Problem: p00029
Buggy submission (Python3, verdict: Wrong Answer):

from collections import defaultdict

d = defaultdict(int)
_input = input()
sentence = [e for e in _input.split()]
l = []

for word in sentence:
    d[word] += 1

times = sorted(d.items(), key=lambda item: item[1], reverse=True)
lengths = sorted(d.items(), key=lambda item: len(item[0]), reverse=True)

print(times[0][1], end=' ')
print(lengths[0][0])

Failing test case input:
anTkh you gor your l`im dna your lecuuqcs

Expected output:
your lecuuqcs


Actual output:
2 lecuuqcs


Fixed submission (verdict: Accepted):

from collections import defaultdict

d = defaultdict(int)
_input = input()

for word in _input.split():
    d[word] += 1

times = sorted(d.items(), key=lambda item: item[1], reverse=True)
lengths = sorted(d.items(), key=lambda item: len(item[0]), reverse=True)

print(times[0][0], end=' ')
print(lengths[0][0])

Problem: p00029
Buggy submission (Python3, verdict: Wrong Answer):
targ = input().split(' ')
mostfre = {}
ansfre = ""
longest = [0,""]
for t in targ:
    if len(t) > longest[0]:
        longest[0],longest[1] = len(t),t
    mostfre[t] = mostfre.get(t,0) + 1
temp = 0
print(mostfre)
for k,v in mostfre.items():
    if v > temp:
        temp = v
        ansfre = k
print(ansfre + ' ' + longest[1])

Failing test case input:
ahTnk you rof your maik and your eecturls

Expected output:
your eecturls


Actual output:
{'ahTnk': 1, 'you': 1, 'rof': 1, 'your': 2, 'maik': 1, 'and': 1, 'eecturls': 1}
your eecturls


Fixed submission (verdict: Accepted):
targ = input().split(' ')
mostfre = {}
ansfre = ""
longest = [0,""]
for t in targ:
    if len(t) > longest[0]:
        longest[0],longest[1] = len(t),t
    mostfre[t] = mostfre.get(t,0) + 1
temp = 0
for k,v in mostfre.items():
    if v > temp:
        temp = v
        ansfre = k
print(ansfre + ' ' + longest[1])

Problem: p00029
Buggy submission (Python3, verdict: Wrong Answer):
import sys
from collections import Counter

if __name__ == '__main__':
    
    
    data = []
    for line in sys.stdin:
        data = line.strip().lower().split(' ')

    print(data)

    
    c = Counter(data)  
    most_frequent_word = c.most_common(1)[0][0]
    
    max_length_word = ''
    for w, freq in c.most_common():
        if len(w) > len(max_length_word):
            max_length_word = w

    
    print('{0} {1}'.format(most_frequent_word, max_length_word))

Failing test case input:
Uhank tzp gpr your mial dma your lfctures

Expected output:
your lfctures


Actual output:
['uhank', 'tzp', 'gpr', 'your', 'mial', 'dma', 'your', 'lfctures']
your lfctures


Fixed submission (verdict: Accepted):
import sys
from collections import Counter

if __name__ == '__main__':
    
    
    data = []
    for line in sys.stdin:
        data = line.strip().strip('.').lower().split(' ')

    

    
    c = Counter(data)  
    most_frequent_word = c.most_common(1)[0][0]
    
    max_length_word = ''
    for w, freq in c.most_common():
        if len(w) > len(max_length_word):
            max_length_word = w

    
    print('{0} {1}'.format(most_frequent_word, max_length_word))
Problem: p00029
Buggy submission (Python3, verdict: Wrong Answer):
s = list(input().split())
maxLen = 0
maxNum = 0
dic = {}
for word in s:
    if not (word in dic):
        dic[word] = 1
    else:
        dic[word] += 1
    if maxNum < dic[word]:
        maxNum = dic[word]
        ansNum = word
    if maxLen < len(word):
        maxLen = len(word)
        ansLen = word
print(ansNum, ansLen)
print(dic)

Failing test case input:
Thank xuo fpr your liam dma your lecsuqet

Expected output:
your lecsuqet


Actual output:
your lecsuqet
{'Thank': 1, 'xuo': 1, 'fpr': 1, 'your': 2, 'liam': 1, 'dma': 1, 'lecsuqet': 1}


Fixed submission (verdict: Accepted):
s = list(input().split())
maxLen = 0
maxNum = 0
dic = {}
for word in s:
    if not (word in dic):
        dic[word] = 1
    else:
        dic[word] += 1
    if maxNum < dic[word]:
        maxNum = dic[word]
        ansNum = word
    if maxLen < len(word):
        maxLen = len(word)
        ansLen = word
print(ansNum, ansLen)

Problem: p00029
Buggy submission (Python3, verdict: Wrong Answer):
import sys
f = sys.stdin

import collections
c = collections.Counter(f.readline().split())

longest = ''
for word in c:
    if len(longest) < len(word):
        longest = word

print(max(c), longest)

Failing test case input:
anTki ytn foq your mi`l aod your leucuqet

Expected output:
your leucuqet


Actual output:
ytn leucuqet


Fixed submission (verdict: Accepted):
import collections
c = collections.Counter(input().split())
longest = ''
for word in c:
    if len(longest) < len(word):
        longest = word

print(c.most_common(1)[0][0], longest)

Problem: p00029
Buggy submission (Python3, verdict: Wrong Answer):
text = input().split()
print(max(text), max(text, key=len))

Failing test case input:
knahU yov fnr your mlia m`d your rlcttees

Expected output:
your rlcttees


Actual output:
yov rlcttees


Fixed submission (verdict: Accepted):
text = input().split()
print(max(text, key=text.count), max(text, key=len))

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



l = input().split()

len_m = 0
for e in l:
    if len_m < len(e):
        len_m = len(e)
        a1 = e
    
d = {}

for e in l:
    if e not in d:
        d.update({
            e: 1
        })
    else:
        t = d[e]
        d.update({
            e: (t+1)
        })
print('%s %s' % (max(d),a1))

Failing test case input:
knahT yov fos your mail amd your rerutcel

Expected output:
your rerutcel


Actual output:
yov rerutcel


Fixed submission (verdict: Accepted):



l = input().split()

len_m = 0
for e in l:
    if len_m < len(e):
        len_m = len(e)
        a1 = e
    
d = {}

for e in l:
    if e not in d:
        d.update({
            e: 1
        })
    else:
        t = d[e]
        d.update({
            e: (t+1)
        })
print('%s %s' % (max(d.items(), key=lambda x: x[1])[0],a1))
Problem: p00029
Buggy submission (Python3, verdict: Wrong Answer):
import sys
f = sys.stdin

import collections
c = collections.Counter(f.readline().lower().split())

longest = ''
for word in c:
    if len(longest) < len(word):
        longest = word

print(max(c), longest)

Failing test case input:
ahTnk zou fos your mail ane your keeturbs

Expected output:
your keeturbs


Actual output:
zou keeturbs


Fixed submission (verdict: Accepted):
import collections
c = collections.Counter(input().split())
longest = ''
for word in c:
    if len(longest) < len(word):
        longest = word

print(c.most_common(1)[0][0], longest)
Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
if a>=b:
  print("b"*a)
else:
  print("a"*b)

Failing test case input:
10 22

Expected output:
10101010101010101010101010101010101010101010


Actual output:
aaaaaaaaaaaaaaaaaaaaaa


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
if a>=b:
    print(str(b)*a)
else:
    print(str(a)*b)

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

def main():
  a, b = map(int, sys.stdin.readline().split())
  s = str(b)
  print(s*a)
if __name__ == "__main__":
  main()


Failing test case input:
10 40

Expected output:
10101010101010101010101010101010101010101010101010101010101010101010101010101010


Actual output:
40404040404040404040


Fixed submission (verdict: Accepted):
import sys

def main():
  a, b = map(int, sys.stdin.readline().split())
  s = str(b)
  s1 = s*a
  s = str(a)
  s2 = s * b
  print(s1) if s1 <= s2 else print(s2)
if __name__ == "__main__":
  main()

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
if a>=b:
    print(str(a)*b)
else:
    print(str(b)*a)

Failing test case input:
10 22

Expected output:
10101010101010101010101010101010101010101010


Actual output:
22222222222222222222


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
if a>=b:
    print(str(b)*a)
else:
    print(str(a)*b)

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split())
if a>b:
    str(b)
    print(b*a)
else:
    str(a)
    print(a*b)

Failing test case input:
67 1

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111


Actual output:
67


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())
if a>b:
    b=str(b)
    print(b*a)
else:
    a=str(a)
    print(a*b)

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

for i in range(max(a,b)):
    print(min(a,b))

Failing test case input:
1 76

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111111111111


Actual output:
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1


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

for i in range(max(a,b)):
    ans += (str(min(a,b)))
print(ans)

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

if a[0] >= a[1]:
    print(a[0] * int(a[1]))
else:
    print(a[1] * int(a[0]))

Failing test case input:
32 18

Expected output:
1818181818181818181818181818181818181818181818181818181818181818


Actual output:
323232323232323232323232323232323232


Fixed submission (verdict: Accepted):
a = list(map(str, input().split()))
 
if a[0] <= a[1]:
    print(a[0] * int(a[1]))
else:
    print(a[1] * int(a[0]))
Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split())

A = ''.join([str(a)] * a)
B = ''.join([str(b)] * b)

if A <= B:
    print(A)
else:
    print(B)

Failing test case input:
1 76

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111111111111


Actual output:
1


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

A = ''.join([str(a)] * b)
B = ''.join([str(b)] * a)

if A <= B:
    print(A)
else:
    print(B)

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b = input().split()
a_int = int(a)
b_int = int(b)
ab = int(a*b_int)
ba = int(b*a_int)
if ab >= ba:
    print(ba)
elif ab <= ba:
    print(ab)

Failing test case input:
37 14

Expected output:
14141414141414141414141414141414141414141414141414141414141414141414141414


Actual output:
3737373737373737373737373737


Fixed submission (verdict: Accepted):
a,b = input().split()
a_int = int(a)
b_int = int(b)
ab = a*b_int
ba = b*a_int
if ab >= ba:
    print(ba)
elif ab <= ba:
    print(ab)

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = input().split()
print(a * int(b) if a * int(b) > b * int(a) else b * int(a))


Failing test case input:
37 14

Expected output:
14141414141414141414141414141414141414141414141414141414141414141414141414


Actual output:
3737373737373737373737373737


Fixed submission (verdict: Accepted):
a, b = input().split()
print(a * int(b) if a * int(b) < b * int(a) else b * int(a))

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


Failing test case input:
20 12

Expected output:
1212121212121212121212121212121212121212


Actual output:
min(a, b)


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())
print(str(min(a, b)) * max(a, b))

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split())
if a < b: 
  print(b*a)
else:
  print(a*b)

Failing test case input:
32 18

Expected output:
1818181818181818181818181818181818181818181818181818181818181818


Actual output:
576


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

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split())
A = int(pow(a, b))
B = int(pow(b, a))
if A >= B:
    print(A)
else:
    print(B)

Failing test case input:
10 25

Expected output:
10101010101010101010101010101010101010101010101010


Actual output:
10000000000000000000000000


Fixed submission (verdict: Accepted):
a, b = input().split()
A = a*int(b)
B = b*int(a)
if a < b:
    print(A)
else:
    print(B)
Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split())

aa = ''.join([str(a) for i in range(b)])
bb = ''.join([str(b) for j in range(a)])

lst = [aa, bb]
print(sorted(lst))

Failing test case input:
10 22

Expected output:
10101010101010101010101010101010101010101010


Actual output:
10101010101010101010101010101010101010101010, 22222222222222222222

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

aa = ''.join([str(a) for i in range(b)])
bb = ''.join([str(b) for j in range(a)])

lst = [aa, bb]
print(sorted(lst)[0])

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

b=max(a,b)
s=min(a,b)

print(str(s)*b)

Failing test case input:
20 12

Expected output:
1212121212121212121212121212121212121212


Actual output:
2020202020202020202020202020202020202020


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

bg=max(a,b)
sm=min(a,b)

print(str(sm)*bg)

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split())
print("a"*b if b >= a else "b"*a)

Failing test case input:
37 14

Expected output:
14141414141414141414141414141414141414141414141414141414141414141414141414


Actual output:
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())
print(str(a)*b if b >= a else str(b)*a)

Problem: p02790
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):



a, b = map(int,input().split())
res = ''
if a<=b:
	for _ in range(b):
		res += 'a'
else:
	for _ in range(a):
		res += 'b'
print(res)

Failing test case input:
10 25

Expected output:
10101010101010101010101010101010101010101010101010


Actual output:
aaaaaaaaaaaaaaaaaaaaaaaaa


Fixed submission (verdict: Accepted):



a, b = map(int,input().split())
res = ''
if a<=b:
	for _ in range(b):
		res += str(a)
else:
	for _ in range(a):
		res += str(b)
print(res)

Problem: p02790
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a,b = map(int,input().split())

A = [a]*b
B = [b]*a

AA = int("".join(map(str, A)))
BB = int("".join(map(str, B)))

if AA >= BB:
    print(BB)
else:
    print(AA)

Failing test case input:
32 18

Expected output:
1818181818181818181818181818181818181818181818181818181818181818


Actual output:
323232323232323232323232323232323232


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

A = [a]*b
B = [b]*a

AA = int("".join(map(str, A)))
BB = int("".join(map(str, B)))

if A >= B:
    print(BB)
else:
    print(AA)

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x,y=map(int,input().split())
print(str(y)*x)

Failing test case input:
1 76

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111111111111


Actual output:
76


Fixed submission (verdict: Accepted):
x,y=map(int,input().split())
print(str(min(x,y))*max(x,y))
Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = [i for i in input().split()]
A = a*int(b)
B = b*int(a)

if A >= B:
  print(B)
  exit()

print(B)

Failing test case input:
10 40

Expected output:
10101010101010101010101010101010101010101010101010101010101010101010101010101010


Actual output:
40404040404040404040


Fixed submission (verdict: Accepted):
a, b = [i for i in input().split()]
A = a*int(b)
B = b*int(a)

if A > B:
  print(B)
  exit()

print(A)

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
a_string=a*int(b)
b_string=b*int(a)
answer=sorted([a_string,b_string])
print(answer[0])

Failing test case input:
10 22

Expected output:
10101010101010101010101010101010101010101010


Actual output:
220


Fixed submission (verdict: Accepted):
a,b=input().split()
a_string=a*int(b)
b_string=b*int(a)
answer=sorted([a_string,b_string])
print(answer[0])

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
c=str("a")*b
d=str("b")*a
if a>=b:
    print(d)
else:
    print(c)


Failing test case input:
10 40

Expected output:
10101010101010101010101010101010101010101010101010101010101010101010101010101010


Actual output:
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
c=str(a)*b
d=str(b)*a
if a>=b:
    print(d)
else:
    print(c)

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

print(str(max(N,M)) * min(N,M))

Failing test case input:
67 1

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111


Actual output:
67


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

print(str(min(N,M)) * max(N,M))

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b = input().split()
print(a*int(b))if a<b else b*int(a)

Failing test case input:
20 12

Expected output:
1212121212121212121212121212121212121212


Actual output:

Fixed submission (verdict: Accepted):
a,b = input().split()
print(a*int(b)if a<b else b*int(a))

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
L, R = map(int,input().split())
l = str(L)
r = str(R)
last_l = ""
last_r = ""
for i in range(L):
    last_l += l 
for i in range(R):
    last_r += r 
    
if L > R:
    print(last_r)
else:
    print(last_l) 

Failing test case input:
10 22

Expected output:
10101010101010101010101010101010101010101010


Actual output:
10101010101010101010


Fixed submission (verdict: Accepted):
L, R = map(int,input().split())
l = str(L)
r = str(R)
last_l = ""
last_r = ""
for i in range(L):
    last_r += r 
for i in range(R):
    last_l += l     
if L > R:
    print(last_r)
else:
    print(last_l)
Problem: p02790
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b = map(int,input().split())

if a <= b:
	for i in range(b):
		print("a",end = "")


Failing test case input:
37 14

Expected output:
14141414141414141414141414141414141414141414141414141414141414141414141414


Actual output:

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

if a <= b:
	for i in range(b):
		print(a,end = "")
else:
	for i in range(a):
		print(b,end = "")

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
if(a<b):
    for i in range (0,b):
        print(a)
else:
    for i in range(0,a):
        print(b)

Failing test case input:
10 25

Expected output:
10101010101010101010101010101010101010101010101010


Actual output:
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
if(a<b):
    A=str(a)
    for i in range (0,b-1):
        A=A+str(a)
    print(A)
else:
    B=str(b)
    for i in range(0,a-1):
        B=B+str(b)
    print(B)

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




def main():
    a,b = map(int, input().split())
    all_a = str(a) * b
    all_b = str(b) * a

    print(all_a)
    print(all_b)

    if (all_a < all_b):
        print(all_a)
    else :
        print(all_b)

if __name__ == '__main__':
    main()


Failing test case input:
37 14

Expected output:
14141414141414141414141414141414141414141414141414141414141414141414141414


Actual output:
3737373737373737373737373737
14141414141414141414141414141414141414141414141414141414141414141414141414
14141414141414141414141414141414141414141414141414141414141414141414141414


Fixed submission (verdict: Accepted):




def main():
    a,b = map(int, input().split())
    all_a = str(a) * b
    all_b = str(b) * a

    
    

    if (all_a < all_b):
        print(all_a)
    else :
        print(all_b)

if __name__ == '__main__':
    main()

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

Failing test case input:
10 33

Expected output:
101010101010101010101010101010101010101010101010101010101010101010


Actual output:
33333333333333333333


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

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
c=min(a,b)
d=max(a,b)
e=""
for i in range(d):
  e+=str(d)
  
print(e+"\n")

Failing test case input:
10 33

Expected output:
101010101010101010101010101010101010101010101010101010101010101010


Actual output:
333333333333333333333333333333333333333333333333333333333333333333



Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
c=min(a,b)
d=max(a,b)
e=""
for i in range(d):
  e+=str(c)
  
print(e+"\n")