ZhenlongDai/ACPR huggingface dataset:
Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=list(map(int,input().split()))
A=B=''
for i in range(b+1):
  A=A+str(a)
for i in range(a+1):
  B=B+str(b)

print(int(min(A,B)))


Failing test case input:
10 33

Expected output:
101010101010101010101010101010101010101010101010101010101010101010


Actual output:
10101010101010101010101010101010101010101010101010101010101010101010


Fixed submission (verdict: Accepted):
a,b=list(map(int,input().split()))
A=B=''
for i in range(b):
  A=A+str(a)
for i in range(a):
  B=B+str(b)

print((min(A,B)))

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

ans = min(int(a * int(b)), int(b * int(a)))
print(ans)


Failing test case input:
1 76

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111111111111


Actual output:
76


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

ans = min(a * int(b), b * int(a))
print(ans)

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

Failing test case input:
67 1

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111


Actual output:
67


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

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

print(min(int(str(A)*B), int(str(B)*A)))

Failing test case input:
67 1

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111


Actual output:
67


Fixed submission (verdict: Accepted):
A, B = map(int, input().split())

print(min(str(A)*B, str(B)*A))

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

aa=[]
bb=[]
for i in range(a):
    aa.append(str(a))

for i in range(a):
    bb.append(str(b))

str1="".join(aa)
str2="".join(bb)

result=[str1,str2]

result=sorted(result)

print(result[0])


Failing test case input:
10 25

Expected output:
10101010101010101010101010101010101010101010101010


Actual output:
10101010101010101010


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

aa=[]
bb=[]

for i in range(a):
    aa.append(str(b))

for i in range(b):
    bb.append(str(a))

str1="".join(aa)
str2="".join(bb)

result=[str1,str2]

result=sorted(result)

print(result[0])

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


a_s = ""
b_s = ""

for _ in range(a):
    a_s = a_s + str(a)

for _ in range(b):
    b_s = b_s + str(b)

if a_s <= b_s:
    print(a_s)
else:
    print(b_s)


Failing test case input:
20 12

Expected output:
1212121212121212121212121212121212121212


Actual output:
121212121212121212121212


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


a_s = ""
b_s = ""

for _ in range(b):
    a_s = a_s + str(a)

for _ in range(a):
    b_s = b_s + str(b)

if a_s <= b_s:
    print(a_s)
else:
    print(b_s)
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())
A=str(a)
B=str(b)
num_1=int(A*b)
num_2=int(B*a)
if num_1>num_2:
  print(num_2)
elif num_1<num_2:
  print(num_1)
elif num_1==num_2:
  print(num_1)

Failing test case input:
10 22

Expected output:
10101010101010101010101010101010101010101010


Actual output:
22222222222222222222


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
A=str(a)
B=str(b)
num_1=int(A*b)
num_2=int(B*a)
if num_1>num_2:
  print(num_1)
elif num_1<num_2:
  print(num_2)
elif num_1==num_2:
  print(num_1)

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

print(str(a)*b)

Failing test case input:
67 1

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111


Actual output:
1


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

print(str(x)*y)

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

Failing test case input:
67 1

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111


Actual output:
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb


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

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B = map(int, input().split())
Ans = ''

if A <= B:
  for i in range(A):
    Ans = Ans + str(B)

else:
  for j in range(B):
    Ans = Ans + str(A)

print(Ans)

Failing test case input:
32 18

Expected output:
1818181818181818181818181818181818181818181818181818181818181818


Actual output:
323232323232323232323232323232323232


Fixed submission (verdict: Accepted):
A,B = map(int, input().split())
Ans = ''

if A <= B:
  for i in range(B):
    Ans = Ans + str(A)

else:
  for j in range(A):
    Ans = Ans + str(B)

print(Ans)

Problem: p02790
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
a,b=map(int,input().split())
A=[str(a)*b]
B=[str(b)*a]
if a>b:
    print(B)
if a<b:
    print(A)
if a==b:
    print(A)

Failing test case input:
1 76

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111111111111


Actual output:
1111111111111111111111111111111111111111111111111111111111111111111111111111

Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
A=[str(a)*b]
B=[str(b)*a]
if a>b:
    print(int(''.join(B)))
if a<b:
    print(int(''.join(A)))
if a==b:
    print(int(''.join(A)))
Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def LI():
  return [int(s) for s in input().split()]
a,b = LI()

if a <= b:
  print(str(a)*a)   
else:
  print(str(b)*b)
  

Failing test case input:
10 33

Expected output:
101010101010101010101010101010101010101010101010101010101010101010


Actual output:
10101010101010101010


Fixed submission (verdict: Accepted):
def LI():
  return [int(s) for s in input().split()]
a,b = LI()

if a <= b:
  print(str(a)*b)   
else:
  print(str(b)*a)

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 25

Expected output:
10101010101010101010101010101010101010101010101010


Actual output:
25252525252525252525


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 = list(map(int, input().split()))

aa = str(a)
bb = ''
for i in range(a):
	bb += str(b)

for i in range(b):
	aa += str(a)


if aa > bb:
	print(bb)
else:
	print(aa)


Failing test case input:
10 22

Expected output:
10101010101010101010101010101010101010101010


Actual output:
1010101010101010101010101010101010101010101010


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

aa = ''
bb = ''
for i in range(a):
	bb += str(b)

for i in range(b):
	aa += str(a)


if aa > bb:
	print(bb)
else:
	print(aa)

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

J = int(N)
K = int(M)

if N > M:
  print(M*K)
else:
  print(N*J)

Failing test case input:
1 76

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111111111111


Actual output:
1


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

J = int(N)
K = int(M)

if N > M:
  print(M*J)
else:
  print(N*K)

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


if a <= b:
    c = a
    for i in range(b-1):
        c = str(c) + str(a)
else:
    c = b
    for i in range(a-1):
        c = str(b) + str(b)
print(c)


Failing test case input:
32 18

Expected output:
1818181818181818181818181818181818181818181818181818181818181818


Actual output:
1818


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


if a <= b:
    c = a
    for i in range(b-1):
        c = str(c) + str(a)
else:
    c = b
    for i in range(a-1):
        c = str(c) + str(b)
print(c)

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

a,b = [int(x) for x in input().split(" ")]
if a<b:
    tmp = a
    a = b
    b = a
print(str(b) * a)

Failing test case input:
10 40

Expected output:
10101010101010101010101010101010101010101010101010101010101010101010101010101010


Actual output:
40404040404040404040404040404040404040404040404040404040404040404040404040404040


Fixed submission (verdict: Accepted):

a,b = [int(x) for x in input().split(" ")]
if a<b:
    tmp = a
    a = b
    b = tmp
print(str(b) * a)
Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = 4, 3
l = [str(a) * int(b), str(b) * int(a)]
l.sort
print(l[0])

Failing test case input:
10 22

Expected output:
10101010101010101010101010101010101010101010


Actual output:
444


Fixed submission (verdict: Accepted):
a, b = input().split()
l = [str(a) * int(b), str(b) * int(a)]
l.sort()
print(l[0])

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:
32 18

Expected output:
1818181818181818181818181818181818181818181818181818181818181818


Actual output:
323232323232323232323232323232323232


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 = input().split()
print(a*int(b) if a>b else b*int(a))

Failing test case input:
10 22

Expected output:
10101010101010101010101010101010101010101010


Actual output:
22222222222222222222


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):
a, b = map(int, input().split())
if a < b:
    b = a
print(str(b)*a)

Failing test case input:
1 76

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111111111111


Actual output:
1


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

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b = input().split()
a1 = a*int(b)
a2 = b*int(a)
print(max(a1,a2))

Failing test case input:
10 33

Expected output:
101010101010101010101010101010101010101010101010101010101010101010


Actual output:
33333333333333333333


Fixed submission (verdict: Accepted):
a,b = input().split()
a1 = a*int(b)
a2 = b*int(a)
print(min(a1,a2))

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b = list(map(int, input().split()))
c = [a,b]
c.sort()
ans = "".join(str(c[0])*c[0])
print(ans)

Failing test case input:
37 14

Expected output:
14141414141414141414141414141414141414141414141414141414141414141414141414


Actual output:
1414141414141414141414141414


Fixed submission (verdict: Accepted):
a,b = list(map(int, input().split()))
c = [a,b]
c.sort()
ans = "".join(str(c[0])*c[1])
print(ans)

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

if a < b:
    ans = str(a)*b
else:
    ans = str(a)*b
print(ans)

Failing test case input:
32 18

Expected output:
1818181818181818181818181818181818181818181818181818181818181818


Actual output:
323232323232323232323232323232323232


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

if a < b:
    ans = str(a)*b
else:
    ans = str(b)*a
print(ans)
Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b = map(int,input().split())
numlist = []
if a > b:
  for i in range(a):
    numlist.append(str(a))
else:
  for i in range(b):
    numlist.append(str(b))
print("".join(numlist))

Failing test case input:
37 14

Expected output:
14141414141414141414141414141414141414141414141414141414141414141414141414


Actual output:
37373737373737373737373737373737373737373737373737373737373737373737373737


Fixed submission (verdict: Accepted):
a,b = map(int,input().split())
numlist = []
if b > a:
  for i in range(b):
    numlist.append(str(a))
else:
  for i in range(a):
    numlist.append(str(b))
print("".join(numlist))

Problem: p02790
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b=(input().split())
ai=int(a)
bi=int(b)
c1=(b*ai)
c2=(a*bi)  
l=[]
l.append(str(c1))
l.append(str(c2))
l.sort
print(l[0])

Failing test case input:
10 33

Expected output:
101010101010101010101010101010101010101010101010101010101010101010


Actual output:
33333333333333333333


Fixed submission (verdict: Accepted):
a,b=(input().split())
ai=int(a)
bi=int(b)
c1=(b*ai)
c2=(a*bi)  
ast=str(c1)
bst=str(c2)
if ast<bst:
  print(ast)
else:
  print(bst)

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b=list(map(int, input().split()))
big = 0
small =0
if a > b:
  big = a
  small = b
else:
  big = b
  small = a
  
s = ""
for i in range(b):
  s += str(small)

print(s)

Failing test case input:
20 12

Expected output:
1212121212121212121212121212121212121212


Actual output:
121212121212121212121212


Fixed submission (verdict: Accepted):
a, b=list(map(int, input().split()))
big = 0
small =0
if a > b:
  big = a
  small = b
else:
  big = b
  small = a
  
s = ""
for i in range(big):
  s += str(small)
  
print(s)

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

a1 = str(a)
b1 = str(b)

for i in range(b):
    a1 = a1 + str(a)
for i in range(a):
    b1 = b1 + str(b)

if a1 < b1:
    print(a1)
else:
    print(b1)

Failing test case input:
10 33

Expected output:
101010101010101010101010101010101010101010101010101010101010101010


Actual output:
10101010101010101010101010101010101010101010101010101010101010101010


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

a1 = ''
b1 = ''

for i in range(b):
    a1 = a1 + str(a)
for i in range(a):
    b1 = b1 + str(b)

if a1 < b1:
    print(a1)
else:
    print(b1)

Problem: p02790
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
a,b = map(str,input().split())
c=a*int(b)
d=b*int(b)
print(min(c,d))

Failing test case input:
67 1

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111


Actual output:
1


Fixed submission (verdict: Accepted):
a,b = map(str,input().split())
c=a*int(b)
d=b*int(a)
print(min(c,d))
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 += 'b'
else:
	for _ in range(a):
		res += 'b'
print(res)

Failing test case input:
10 40

Expected output:
10101010101010101010101010101010101010101010101010101010101010101010101010101010


Actual output:
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb


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 (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split())
if a>=b:
  ans = str(a) * b 
else:
  ans = str(b) * a

print(ans)

Failing test case input:
10 40

Expected output:
10101010101010101010101010101010101010101010101010101010101010101010101010101010


Actual output:
40404040404040404040


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

print(ans)

Problem: p02790
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b = map(int,input().split())
l=[]
if a>=b:
    for i in range(a):
        l.append(b)

print(''.join(map(str,l)))

Failing test case input:
10 40

Expected output:
10101010101010101010101010101010101010101010101010101010101010101010101010101010


Actual output:

Fixed submission (verdict: Accepted):
a,b = map(int,input().split())
l=[]
if a>=b:
    for i in range(a):
        l.append(b)
else:
    for i in range(b):
        l.append(a)

print(''.join(map(str,l)))

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
if a==b:
    n=str(a)
    for i in range(a-1):
        n+str(a)
    print(n)
else:
    if a>b:
        n=str(b)
        for i in range(a-1):
            n+str(b)
        print(n)
    else:
        n=str(a)
        for i in range(b-1):
            n+str(a)
        print(n)
        



Failing test case input:
10 40

Expected output:
10101010101010101010101010101010101010101010101010101010101010101010101010101010


Actual output:
10


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

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

print(out)


Failing test case input:
20 12

Expected output:
1212121212121212121212121212121212121212


Actual output:
202020202020202020202020


Fixed submission (verdict: Accepted):
A,B = map(int,input().split())
if A <= B :
  out = str(A) * B
else:
  out = str(B) * A

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

Failing test case input:
37 14

Expected output:
14141414141414141414141414141414141414141414141414141414141414141414141414


Actual output:
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa


Fixed submission (verdict: Accepted):
a,b = (int(x) for x in input().split())
if a>b:
	x = a
	a = b
	b = x
print("%d"%a*b)

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B = list(map(int,input().split()))
para_a = str(B)
para_b = str(A)

for i in range(A-1):
    para_a = para_a + str(B)

for i in range(B-1):
    para_b = para_b + str(A)

N = [para_a,para_b]

sorted(N)

print(N[0])


Failing test case input:
10 25

Expected output:
10101010101010101010101010101010101010101010101010


Actual output:
25252525252525252525


Fixed submission (verdict: Accepted):
A,B = list(map(int,input().split()))
para_a = str(B)
para_b = str(A)

for i in range(A-1):
    para_a = para_a + str(B)

for i in range(B-1):
    para_b = para_b + str(A)

if para_a < para_b:
    print(para_a)
else:
    print(para_b)

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=(int(x) for x in input().split())
i = 0
if a > b:
  while i < b:
    print(str(a))
    i += 1
else:
  while i < a:
    print(str(b))
    i += 1

Failing test case input:
67 1

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111


Actual output:
67


Fixed submission (verdict: Accepted):
a,b=(int(x) for x in input().split())
i = 0
if a > b:
  while i < a:
    print(str(b), end="")
    i += 1
else:
  while i < b:
    print(str(a), end="")
    i += 1

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

l = "a"*b
m = "b"*a

if l < m:
    print(l)
else:
    print(m)

Failing test case input:
10 22

Expected output:
10101010101010101010101010101010101010101010


Actual output:
aaaaaaaaaaaaaaaaaaaaaa


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

l = str(a)*b
m = str(b)*a

if l < m:
    print(l)
else:
    print(m)

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
if a>b:
  print(int(str(a)*b))
elif a<b:
  print(int(str(b)*a))
else:
  print(int(str(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:
  print(int(str(b)*a))
elif a<b:
  print(int(str(a)*b))
else:
  print(int(str(a)*b))

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

Failing test case input:
10 33

Expected output:
101010101010101010101010101010101010101010101010101010101010101010


Actual output:
33333333333333333333


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

Failing test case input:
1 76

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111111111111


Actual output:
76


Fixed submission (verdict: Accepted):
a = list(map(int,input().split()))
b = a[0] - a[1]
if b == 0 :
	print(str(a[0]) * a[0])
else : print(str(min(a[0], a[1])) * max(a[0], a[1]))

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b = input().split()
a = int(a)
b = int(b)
astr = ""
bstr = ""
for i in range(0,a):
	astr += str(a)

for i in range(0,b):
	bstr += str(b)

if ord(astr[:1]) > ord(bstr[:1]):
	print(bstr)
elif ord(astr[:1]) < ord(bstr[:1]):
	print(astr)
else:
	print(astr)

Failing test case input:
10 40

Expected output:
10101010101010101010101010101010101010101010101010101010101010101010101010101010


Actual output:
10101010101010101010


Fixed submission (verdict: Accepted):
a,b = input().split()
a = int(a)
b = int(b)
astr = ""
bstr = ""
for i in range(0,a):
	astr += str(b)

for i in range(0,b):
	bstr += str(a)

if ord(astr[:1]) > ord(bstr[:1]):
	print(bstr)
elif ord(astr[:1]) < ord(bstr[:1]):
	print(astr)
else:
	print(astr)

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


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

if a >= b:
    print(''.join([str(b)] * a))

Failing test case input:
1 76

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111111111111


Actual output:

Fixed submission (verdict: Accepted):


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


print(''.join([str(min(a, b))] * max(a, b)))

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b = input().split()
 
a_ = a * int(a)
b_ = b * int(b)
 
moji = sorted([a_ ,b_])
 
print(moji[0])

Failing test case input:
67 1

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111


Actual output:
1


Fixed submission (verdict: Accepted):
a,b = input().split()
 
a_ = a * int(b)
b_ = b * int(a)
 
moji = sorted([a_ ,b_])
 
print(moji[0])

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

Failing test case input:
1 76

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111111111111


Actual output:
76


Fixed submission (verdict: Accepted):
a,b=input().split()
if a*int(b)>=b*int(a):
    print(b*int(a))
else:
    print(a*int(b))
Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=list(map(int,input().split()))
A=B=''
for i in range(b+1):
  A=A+str(a)
for i in range(a+1):
  B=B+str(b)

print(min(A,B))

Failing test case input:
10 33

Expected output:
101010101010101010101010101010101010101010101010101010101010101010


Actual output:
10101010101010101010101010101010101010101010101010101010101010101010


Fixed submission (verdict: Accepted):
a,b=list(map(int,input().split()))
A=B=''
for i in range(b):
  A=A+str(a)
for i in range(a):
  B=B+str(b)

print((min(A,B)))

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


Failing test case input:
67 1

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111


Actual output:

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

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


Failing test case input:
1 76

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111111111111


Actual output:

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

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

Failing test case input:
10 25

Expected output:
10101010101010101010101010101010101010101010101010


Actual output:
25252525252525252525252525252525252525252525252525


Fixed submission (verdict: Accepted):
a, b = (int(x) for x in input().split())
aa = str(a) * b
bb = str(b) * a
if aa < bb:
    print(aa)
else:
    print(bb)

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


Failing test case input:
37 14

Expected output:
14141414141414141414141414141414141414141414141414141414141414141414141414


Actual output:
3737373737373737373737373737


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())
c = ''
if a >= b:
  for i in range(a):
    c += str(b)
else:
  for i in range(b):
    c += str(a)
    
print(int(c))

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



Failing test case input:
20 12

Expected output:
1212121212121212121212121212121212121212


Actual output:
bbbbbbbbbbbbbbbbbbbb


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
if a==b:
    print(f"{a}"*a)
elif a>b:
    print(f"{b}"*a)
elif a<b:
    print(f"{a}"*b)
Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b = map(str, input().split())

lis = []
res_a = a
res_b = b

for i in range(int(b)-1):
  res_a += a
lis.append(res_a)

for i in range(int(a)-1):
  res_b += b
lis.append(res_b)

print(int(sorted(lis)[0][0]))
  

Failing test case input:
10 25

Expected output:
10101010101010101010101010101010101010101010101010


Actual output:
1


Fixed submission (verdict: Accepted):
a,b = map(str, input().split())
 
lis = []
res_a = a
res_b = b
 
for i in range(int(b)-1):
  res_a += a
lis.append(res_a)
 
for i in range(int(a)-1):
  res_b += b
lis.append(res_b)
 
print(int(sorted(lis)[0]))

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

import sys


def solve(a: int, b: int):
    if a>b:
        print("".join(str(b)*a))
    else:
        print("".join(str(b)*a))
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    a = int(next(tokens))  
    b = int(next(tokens))  
    solve(a, b)

if __name__ == '__main__':
    main()


Failing test case input:
10 40

Expected output:
10101010101010101010101010101010101010101010101010101010101010101010101010101010


Actual output:
40404040404040404040


Fixed submission (verdict: Accepted):

import sys


def solve(a: int, b: int):
    if a>b:
        print("".join(str(b)*a))
    else:
        print("".join(str(a)*b))
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    a = int(next(tokens))  
    b = int(next(tokens))  
    solve(a, b)

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('b'*a)
else:
  print('a'*b)

Failing test case input:
1 76

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111111111111


Actual output:
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa


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):
M = input().split()
i = 0
a = ''
b = ''
for i in range(int(M[0])):
    a += str(M[1])
alfa = int(a)
for i in range(int(M[1])):
    b += str(M[0])
beta = int(b)
delta = str(min(alfa,beta))
print(delta)

Failing test case input:
1 76

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111111111111


Actual output:
76


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())
ans = ""
if a>b:
    for i in range(a):
        ans = ans + str(a)
    print(ans)
else:
    for i in range(b):
        ans = ans + str(b)
    print(ans)

Failing test case input:
10 25

Expected output:
10101010101010101010101010101010101010101010101010


Actual output:
25252525252525252525252525252525252525252525252525


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

ans = ""
if a>b:
    for i in range(a):
        ans = ans + str(b)
    print(ans)
else:
    for i in range(b):
        ans = ans + str(a)
    print(ans)

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

else:
    for i in range(0,int(b)):
        print(b,end="")


Failing test case input:
10 33

Expected output:
101010101010101010101010101010101010101010101010101010101010101010


Actual output:
333333333333333333333333333333333333333333333333333333333333333333

Fixed submission (verdict: Accepted):
(a, b) = map(str, input().split())
if a>=b:
    for i in range(0,int(a)):
        print(b,end="")

else:
    for i in range(0,int(b)):
        print(a,end="")

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

Failing test case input:
32 18

Expected output:
1818181818181818181818181818181818181818181818181818181818181818


Actual output:
323232323232323232323232323232323232


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

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

Failing test case input:
20 12

Expected output:
1212121212121212121212121212121212121212


Actual output:
202020202020202020202020


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

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


Failing test case input:
10 25

Expected output:
10101010101010101010101010101010101010101010101010


Actual output:
250


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.8.2), verdict: Wrong Answer):
a,b=map(int,input().split())
if str(a)*b>str(b)*a:
  print(str(a)*b)
else:
  print(str(b)*a)


Failing test case input:
10 40

Expected output:
10101010101010101010101010101010101010101010101010101010101010101010101010101010


Actual output:
40404040404040404040


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
c=int(str(a)*b)
d=int(str(b)*a)
if c>d:
  print(str(a)*b)
else:
  print(str(b)*a)
Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = min([int(i) for i in input().split()])
print(str(n)*int(n))

Failing test case input:
1 76

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111111111111


Actual output:
1


Fixed submission (verdict: Accepted):
n = [int(i) for i in input().split()]
print(str(min(n)) * max(n))

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


if a < b :
    print(a*str(b))
else :
    print(b*str(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(a)*b)
else :
    print(str(b)*a)

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n,m = list(map(int,input().split()))

if n > m:
  for i in range(n):
    print(m)
else:
  for i in range(m):
    print(n)

Failing test case input:
37 14

Expected output:
14141414141414141414141414141414141414141414141414141414141414141414141414


Actual output:
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14
14


Fixed submission (verdict: Accepted):
n,m = list(map(int,input().split()))
 
if n > m:
  for i in range(n):
    print(str(m),end="")
else:
  for i in range(m):
    print(str(n),end="")

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

if a > b:
    for i in range(0, a + 1):
        anser = str(b) * i
if a == b:
    for i in range(0, a + 1):
        anser = str(b) * i
if a < b:
    for i in range(0, b + 1):
        anser = str(b) * i
print(anser)

Failing test case input:
10 25

Expected output:
10101010101010101010101010101010101010101010101010


Actual output:
25252525252525252525252525252525252525252525252525


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

if a > b:
    for i in range(0, a + 1):
        anser = str(b) * i
if a == b:
    for i in range(0, a + 1):
        anser = str(b) * i
if a < b:
    for i in range(0, b + 1):
        anser = str(a) * i
print(anser)

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


Failing test case input:
10 33

Expected output:
101010101010101010101010101010101010101010101010101010101010101010


Actual output:
10101010101010101010


Fixed submission (verdict: Accepted):
a, b = input().split()
if (int(b) <= int(a)): print(b * int(a)); exit(0)
else: print(a * int(b)); exit(0)
Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split())
c = max(a, b)
d = min(a, b)
ans = str(c)*d
print(ans)

Failing test case input:
32 18

Expected output:
1818181818181818181818181818181818181818181818181818181818181818


Actual output:
323232323232323232323232323232323232


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

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


Failing test case input:
20 12

Expected output:
1212121212121212121212121212121212121212


Actual output:
20
20
20
20
20
20
20
20
20
20
20
20


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
if a<b:
    for i in range(b):
        print(a,end="")
elif a==b:
    for i in range(b):
        print(a,end="")
elif a>b:
    for i in range(a):
        print(b,end="")

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B = list(map(int,input().split()))
para_a = str(B)
para_b = str(A)

for i in range(A-1):
    para_a = para_a + str(B)

for i in range(B-1):
    para_b = para_b + str(A)

N = [para_a,para_b]
print(N)
sorted(N)

print(N[0])


Failing test case input:
67 1

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111


Actual output:
['1111111111111111111111111111111111111111111111111111111111111111111', '67']
1111111111111111111111111111111111111111111111111111111111111111111


Fixed submission (verdict: Accepted):
A,B = list(map(int,input().split()))
para_a = str(B)
para_b = str(A)

for i in range(A-1):
    para_a = para_a + str(B)

for i in range(B-1):
    para_b = para_b + str(A)

if para_a < para_b:
    print(para_a)
else:
    print(para_b)

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

Failing test case input:
20 12

Expected output:
1212121212121212121212121212121212121212


Actual output:
202020202020202020202020


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

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

s1 = "a" *b
s2 = "b" *a
if s1 < s2:
    print(s1)
else:
    print(s2)

Failing test case input:
20 12

Expected output:
1212121212121212121212121212121212121212


Actual output:
aaaaaaaaaaaa


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

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

if A >= B:
    print(AB)
else:
    print(BA)

Failing test case input:
10 33

Expected output:
101010101010101010101010101010101010101010101010101010101010101010


Actual output:
33333333333333333333


Fixed submission (verdict: Accepted):
A,B = map(str,input().split())
AB = A * int(B)
BA = B * int(A)

if A < B:
    print(AB)
elif A > B:
    print(BA)
else:
    print(AB)

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n, m = input().strip().split()
if(n<m):
  for i in range(int(m)-1):
    print(n)
else:
  for i in range(int(n)-1):
    print(m)

Failing test case input:
67 1

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111


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


Fixed submission (verdict: Accepted):
n, m = input().strip().split()
a = ""
if(n<m):
  for i in range(int(m)):
    a += n
else:
  for i in range(int(n)):
    a += m
print(a)

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def main():
    a, b = input().split()
    A = a*int(a)
    B = b*int(b)
    ans = sorted([A, B])
    print(ans[0])


if __name__ == "__main__":
    main()

Failing test case input:
32 18

Expected output:
1818181818181818181818181818181818181818181818181818181818181818


Actual output:
181818181818181818181818181818181818


Fixed submission (verdict: Accepted):
def main():
    a, b = input().split()
    A = a*int(b)
    B = b*int(a)
    ans = sorted([A, B])
    print(ans[0])


if __name__ == "__main__":
    main()

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

a,b = list(map(int, input().split()))
print(max(str(a)*b, str(b)*a))

Failing test case input:
32 18

Expected output:
1818181818181818181818181818181818181818181818181818181818181818


Actual output:
323232323232323232323232323232323232


Fixed submission (verdict: Accepted):

a,b = list(map(int, input().split()))
print(min(str(a)*b, str(b)*a))

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
a_=a*b
b_=b*a
s=[a_,b_]
s.sort()
print(s[0])

Failing test case input:
67 1

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111


Actual output:
67


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
a_=str(a)*b
b_=str(b)*a
s=[a_,b_]
s.sort()
print(s[0])

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
str=list(input().split())
cal=[int(s) for s in str]

for i in range(2):
    str[i]+=str[i]*(cal[i]-1)

str.sort()
print(str[0])



Failing test case input:
10 40

Expected output:
10101010101010101010101010101010101010101010101010101010101010101010101010101010


Actual output:
10101010101010101010


Fixed submission (verdict: Accepted):
str=list(input().split())
cal=[int(s) for s in str]

str[0]+=str[0]*(cal[1]-1)
str[1]+=str[1]*(cal[0]-1)

str.sort()
print(str[0])
Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B = map(int,input().split())
AB = str(A) * B
BA = str(B) * A

if A > B:
    print(AB)
elif A < B:
    print(BA)
else:
    print(AB)

Failing test case input:
10 25

Expected output:
10101010101010101010101010101010101010101010101010


Actual output:
25252525252525252525


Fixed submission (verdict: Accepted):
A,B = map(str,input().split())
AB = A * int(B)
BA = B * int(A)

if A < B:
    print(AB)
elif A > B:
    print(BA)
else:
    print(AB)

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

Failing test case input:
32 18

Expected output:
1818181818181818181818181818181818181818181818181818181818181818


Actual output:
323232323232323232323232323232323232


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

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=list(map(int,input().split()))
A=B=''
for i in range(b+1):
  A=A+str(a)
for i in range(a+1):
  B=B+str(b)

print(str(min(A,B)))

Failing test case input:
10 33

Expected output:
101010101010101010101010101010101010101010101010101010101010101010


Actual output:
10101010101010101010101010101010101010101010101010101010101010101010


Fixed submission (verdict: Accepted):
a,b=list(map(int,input().split()))
A=B=''
for i in range(b):
  A=A+str(a)
for i in range(a):
  B=B+str(b)

print((min(A,B)))

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

aa=a*int(b)
bb=b*int(a)

print(aa if a>b else bb)

Failing test case input:
10 33

Expected output:
101010101010101010101010101010101010101010101010101010101010101010


Actual output:
33333333333333333333


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

aa=a*int(b)
bb=b*int(a)

print(bb if a>b else aa)

Problem: p02790
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
a,b=map(int,input().split())
print(str(max(a,b))*min(a,b))

Failing test case input:
10 25

Expected output:
10101010101010101010101010101010101010101010101010


Actual output:
25252525252525252525


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())
print(str(a)*b if a>=b else str(b)*a)

Failing test case input:
10 25

Expected output:
10101010101010101010101010101010101010101010101010


Actual output:
25252525252525252525


Fixed submission (verdict: Accepted):

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


Failing test case input:
67 1

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111


Actual output:
1111111111111111111111111111111111111111111111111111111111111111111
67


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

Problem: p02790
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a=input().split(" ")
x1=""
x2=""

for j in range(int(a[0])):
    x1=x1+a[0]

for y in range(int(a[1])):
    x2=x2+a[1]

z1=int(x1)
z2=int(x2)

if x1>x2:
	print(x1)
elif x1<x2:
	print(x2)
else:
	print(x1)







Failing test case input:
32 18

Expected output:
1818181818181818181818181818181818181818181818181818181818181818


Actual output:
3232323232323232323232323232323232323232323232323232323232323232


Fixed submission (verdict: Accepted):
a=input().split(" ")
x1=""
x2=""

for j in range(int(a[0])):
    x1=x1+a[1]

for y in range(int(a[1])):
    x2=x2+a[0]

z1=int(x1)
z2=int(x2)

if x1<x2:
	print(x1)
elif x1>x2:
	print(x2)
else:
	print(x1)

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

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


Failing test case input:
10 22

Expected output:
10101010101010101010101010101010101010101010


Actual output:
10101010101010101010


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

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

Problem: p02790
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=input().split()
c=int(a)
d=int(b)
e=(a*d)
f=(b*c)
g=e[0:1]
h=f[0:1]
if g<=h:
    print(g)
else:
    print(h)


Failing test case input:
67 1

Expected output:
1111111111111111111111111111111111111111111111111111111111111111111


Actual output:
1


Fixed submission (verdict: Accepted):
a,b=input().split()
c=int(a)
d=int(b)
e=(a*d)
f=(b*c)
g=e[0:1]
h=f[0:1]
if g<=h:
    print(e)
else:
    print(f)

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

x = a if a<=b else b

for _ in range(x):
    print(x, end='')

Failing test case input:
10 25

Expected output:
10101010101010101010101010101010101010101010101010


Actual output:
10101010101010101010

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

(x, y) = (a, b) if a<=b else (b, a)

for _ in range(y):
    print(x, end='')

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

Failing test case input:
20 12

Expected output:
1212121212121212121212121212121212121212


Actual output:
202020202020202020202020


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