TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b = map(int,input().split())
a_l = str(a)*a
b_l = str(b)*b
if a_l>b_l:
  print(b_l)
elif b_l>a_l:
  print(a_l)
else:
  print(a_l)


a,b = map(int,input().split())
a_l = str(a)*a
b_l = str(b)*b
if a>b:
  print(b_l)
elif b<a:
  print(a_l)
else:
  print(a_l)


a,b = map(int,input().split())
k = str(a)
l = str(b)
X = k*b
Y = l*a
if (X < Y):
  print(X)
else:
  print(Y)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

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

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

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

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

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
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)

A,B = map(str,input().split())
AB = A * int(B)
BA = B * int(A)

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

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)

A,B = map(str,input().split())
AB = A * int(B)
BA = B * int(A)

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

A,B = map(str,input().split())
AB = A * int(B)
BA = B * int(A)

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


Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b=map(int,input().split())
l=[[1,1],[2,11],[3,111],[4,1111],[5,11111],[6,111111],[7,1111111],[8,11111111],[9,111111111]]

c=0
d=0

for i in range(9):
    if l[i][0]==a:
        c=b*l[i][1]
    if l[i][0]==b:
        d=a*l[i][1]
print(min(c,d))


a,b=map(int,input().split())
l=[[1,1],[2,11],[3,111],[4,1111],[5,11111],[6,111111],[7,1111111],[8,11111111],[9,111111111]]

c=0
d=0

for i in range(9):
    if l[i][0]==a:
        c=b*l[i][1]
    if l[i][0]==b:
        d=a*l[i][1]
if a>b:
    print(c)
else:
    print(d)

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b = map(int,input().split())
ans = ''
if a <= b:
    for _ in range(b):
        ans.join(a)
else: 
    for _ in range(a):
        ans.join(b)
print(ans)


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


Verdicts: Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
import numpy as np
a = input()
b = input()
a_int =int(a)
b_int = int(b)
# print(a)
# print(b)
c = ""
if(a<b):
    for i in range(b_int):
        c += str(a)
    print(c)

else:
    for i in range(a_int):
        c += str(b)
    print(c)

import numpy as np
a,b=input().split()
# print(a)
# print(b)
a_int =int(a)
b_int = int(b)
# print(a)
# print(b)
c = ""
if(a<b):
    for i in range(b_int):
        c += str(a)
    print(c)

else:
    for i in range(a_int):
        c += str(b)
    print(c)

Verdicts: Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

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

s1 = ''
s2 = ''

for i in range(a):
  s1 += str(a)

for i in range(b):
  s2 += str(b)
  
if a < b:
  print(s1)
else:
  print(s2)

a = int(input())
b = int(input())

s1 = ''
s2 = ''

for i in range(a):
  s1 += str(a)

for i in range(b):
  s2 += str(b)
  
if a < b:
  print(s1)
else:
  print(s2)

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

s1 = ''
s2 = ''

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

for i in range(a):
  s2 += str(b)
  
if a < b:
  print(s1)
else:
  print(s2)

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a, b = map(int, input().split())
print('min(a, b)')


a, b = map(int, input().split())
print('min(a, b)' * max(a, b))


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


Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b = input().split()
ab=''
ba=''
for i in range(int(b)):
  ab += a
for i in range(int(a)):
  ba += b
l = [ab,ba]
sorted(l)
print(l[0])

a,b = input().split()
ab=''
ba=''
for i in range(int(b)):
  ab += a
for i in range(int(a)):
  ba += b
l = [ab,ba]
ll = sorted(l)
print(ll[0])

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b= map(str, input().split())
a = a*int(b)
b = b*int(a)

if a < b:
    print(a)
else:
    print(b)
# p = list(map(int,input().split()))

# count = 0
# val = sum(p[0:k])
# val_lis = [val]
# mx_val = val
# index = 0
# mx_index = 0
# for i,j in enumerate(p[k:]):
#     val = val - p[index] + j
#     val_lis.append(val)
#     index +=1
#     if val > mx_val:
#         mx_index = index
#         mx_val = val 
    
# ans = 0

#     ans += ((p[mx_index + i]+1.0)*(p[mx_index+i]))/ (p[mx_index+i] *2.0)
# print(ans)  





# print(sum(h[k:]))

# s,t= map(str, input().split())
# a,b= map(int, input().split())

# print("x"*len(u))

# if(u == s):
#     print(a-1,b)
# else:
#     print(a,b-1)


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

if a < b:
    print(a)
else:
    print(b)
# p = list(map(int,input().split()))

# count = 0
# val = sum(p[0:k])
# val_lis = [val]
# mx_val = val
# index = 0
# mx_index = 0
# for i,j in enumerate(p[k:]):
#     val = val - p[index] + j
#     val_lis.append(val)
#     index +=1
#     if val > mx_val:
#         mx_index = index
#         mx_val = val 
    
# ans = 0

#     ans += ((p[mx_index + i]+1.0)*(p[mx_index+i]))/ (p[mx_index+i] *2.0)
# print(ans)  





# print(sum(h[k:]))

# s,t= map(str, input().split())
# a,b= map(int, input().split())

# print("x"*len(u))

# if(u == s):
#     print(a-1,b)
# else:
#     print(a,b-1)


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

if a < b:
    print(a)
else:
    print(b)
# p = list(map(int,input().split()))

# count = 0
# val = sum(p[0:k])
# val_lis = [val]
# mx_val = val
# index = 0
# mx_index = 0
# for i,j in enumerate(p[k:]):
#     val = val - p[index] + j
#     val_lis.append(val)
#     index +=1
#     if val > mx_val:
#         mx_index = index
#         mx_val = val 
    
# ans = 0

#     ans += ((p[mx_index + i]+1.0)*(p[mx_index+i]))/ (p[mx_index+i] *2.0)
# print(ans)  





# print(sum(h[k:]))

# s,t= map(str, input().split())
# a,b= map(int, input().split())

# print("x"*len(u))

# if(u == s):
#     print(a-1,b)
# else:
#     print(a,b-1)


a,b= map(str, input().split())
ab = a*int(b)
ba = b*int(a)
if ab < ba:
    print(ab)
else:
    print(ba)
# p = list(map(int,input().split()))

# count = 0
# val = sum(p[0:k])
# val_lis = [val]
# mx_val = val
# index = 0
# mx_index = 0
# for i,j in enumerate(p[k:]):
#     val = val - p[index] + j
#     val_lis.append(val)
#     index +=1
#     if val > mx_val:
#         mx_index = index
#         mx_val = val 
    
# ans = 0

#     ans += ((p[mx_index + i]+1.0)*(p[mx_index+i]))/ (p[mx_index+i] *2.0)
# print(ans)  





# print(sum(h[k:]))

# s,t= map(str, input().split())
# a,b= map(int, input().split())

# print("x"*len(u))

# if(u == s):
#     print(a-1,b)
# else:
#     print(a,b-1)


Verdicts: Wrong Answer

Runtime Error

Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b = input().split()

a_ = a * int(a)
b_ = b * int(b)

moji = sorted([a_ ,b_])

print(mojj[0])

a,b = input().split()
 
a_ = a * int(a)
b_ = b * int(b)
 
moji = sorted([a_ ,b_])
 
print(moji[0])

a,b = input().split()
 
a_ = a * int(b)
b_ = b * int(a)
 
moji = sorted([a_ ,b_])
 
print(moji[0])

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b = list(map(int, input().split()))
c = [a,b]
c.sort()
ans = "".join(str(c[0])*c[0])
print(ans)

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

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
#AtCorder
def main():
	a,b=map(int, input().split())
	if a*10**b <=b*10**a:
		print(str(a)*b)
	else:
		print(str(b)*a)
main()

#AtCorder
def main():
	a,b=map(int, input().split())
	for i in range(a)
	if a*10**b <=b*10**a:
		print(str(a)*b)
	else:
		print(str(b)*a)
main()

#AtCorder
def main():
	a,b=map(int, input().split())
	if a <=b:
		print(str(a)*b)
	else:
		print(str(b)*a)
main()

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

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

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

A, B = map(int, input())

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

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

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

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a, b = map(int, input().split())
print(a*int(b) if a*int(b) <= b*int(a) else b*int(a))

A, B = input()
print(min(A*int(B), B*int(A)))

a, b = map(int, input().split())
print(a*int(b) if a<=b else b*int(a))


A, B = input().split()
print(min(A*int(B), B*int(A)))

Verdicts: Wrong Answer

Runtime Error

Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a, b = [int(x) for x in input().split()]
if a <= b:
  return str(a) * b
else:
  return str(b) * a

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

Verdicts: Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

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


A = str(a)
B = str(b)

c =A
d=B

for i in range(b):
    c = c+A;

for i in range(a):
    d = d+B
    
if int(c) > int(d):
    print(d)
else:
    print(c)

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


A = str(a)
B = str(b)

c =""
d=""

for i in range(b):
    c = c+A;

for i in range(a):
    d = d+B
    
if c > d:
    print(d)
else:
    print(c)

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b=input().split()
print(str(min(a,b))*max(a,b))

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


Verdicts: Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
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)

n, m = input().strip().split()
if(n<m):
  for i in range(int(m)):
    print(n)
else:
  for i in range(int(n)):
    print(m)

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)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b = input().split()
if int(a*int(b)) < int(b*int(a)):
  print(int(a*int(b)))
else:
  print(int(b*int(a)))

a,b = input().split()
print(a*int(b) if a>b else b*int(a))

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

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b=input().split()
c = a**b
d = b**a
if a<b:
  print(c)
else:
  print(d)

a,b=input().split()
c = str(a)**b
d = str(b)**a
if a<b:
  print(c)
else:
  print(d)

a,b=map(int,input().split())
c = ("a")**b
d = ("b")**a
if a<b:
  print(c)
else:
  print(d)

a,b=input().split()
c = str(a)*int(b)
d = str(b)*int(a)
if a<b:
  print(c)
else:
  print(d)

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

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

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


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

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


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)


Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b = map(int,input().split())
if a>b:
  print(str(b)*a)a,b = map(int,input().split())
if a>b:
  print(str(b)*a)
else:
  print(str(a)*b)

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

Verdicts: Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b = map(int,input().split())
if a >= b:
  print(b*int(a))
else:
  print(a*int(b))

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


Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b = map(int, input().split())
print(min(a * int(b), b * int(a)))

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

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
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])

def i():
	return int(input())
def i2():
	return map(int,input().split())
def s():
	return str(input())
def l():
	return list(input())
def intl():
	return list(int(k) for k in input().split())

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

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

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b=map(int,input().split())
hai1=[]
hai2=[]
for k in range(0,a):
  hai1.append(str(b))
for i in range(0,b):
  hai2.append(str(a))
ak="".join(hai1)
bk="".join(hai2)
c=[0]*2
c[0]=int(ak)
c[1]=int(bk)
c.sort()
print(c[0])

a,b=map(int,input().split())
hai1=[]
hai2=[]
for k in range(0,a):
  hai1.append(str(b))
for i in range(0,b):
  hai2.append(str(a))
ak="".join(hai1)
bk="".join(hai2)
c=[0]*2
c[0]=ak
c[1]=bk
c.sort()
print(int(c[0]))

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
myList = []
a,b=map(int,input().split())
if(b>a):
    for x in range(b):
        myList.append(a)
    for x in range(len(myList)): 
        print(myList[x])
else:
    for x in range(a):
        myList.append(b)
    for x in range(len(myList)): 
        print(myList[x])

a,b=map(int,input().split())
if(b>a):
    for x in range(a):
        print(b)
else:
    for x in range(b):
        print(a)

a,b = map(int, input().split())
aList = [b]*a
bList = [a]*b
i = 0
l = min(len(bList),len(aList))
if a==b:
    pass
else:
    while aList[i]==bList[i]:
        i+=1
        if i+1==l:
            break
if aList[i]>bList[i]:
    print(*bList,sep="")
else:
    print(*aList,sep="")

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
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)

a,b = map(int, input().split())
ans = ""
if a>b:
    for i in range(a):
        ans = ans + str(a)
    print(int(ans))
else:
    for i in range(b):
        ans = ans + str(b)
    print(int(ans))

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)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a, b = map(int, input().split())
print(str(max(a,b))*min(a,b))

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

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
n, m = input().split()
if n*int(m) > m*int(n):
  print(n*int(m))
else:
  print(m*int(n))

n, m = input().split()
if n*int(m) < m*int(n):
  print(n*int(m))
else:
  print(m*int(n))


Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b =map(int,input().split())
if a > b:
    print('b'*a)
else:
    print('a'*b)

a,b=map(str,input().split())
c = a*len(a)
d = b*len(b)
if str(c) <= str(d):
  print(str(c))
else:
  print(str(d))

a,b=map(str,input().split())
c = a*len(b)
d = b*len(a)
if str(c) >= str(d):
  print(str(c))
else:
  print(str(d))

a,b=map(str,input().split())
c = a*len(b)
d = b*len(a)
if str(c) <= str(d):
  print(str(c))
else:
  print(str(d))

a,b = map(int,input().split())
A = str(a)*b
B = str(b)*a
if A <= B:
  print(A)
else:
  print(B)


Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a, b = input().split()
if a >= b:
  print(a*int(b))
  break
else:
  print(b*int(a))

a, b = input().split()
print(a*int(b) if a < b else b*int(a))

Verdicts: Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a, b = map(int,input().split())
a = ("".join(a))*b

a, b = map(int,input().split())
a1, b1 = str(a) * b, str(b) * a
ans = min(a1[0],b1[0])
if int(ans) == b:
  print(b1)
else:
  print(a1)

Verdicts: Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
N,M = map(int, input().split())

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

N,M = map(int, input().split())

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

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
#!/usr/bin/env python3
a, b = input().split(" ")
for i in range(a):
    a += a
for i in range(b):
    b += b
print(sorted([a, b])[0])

#!/usr/bin/env python3
a, b = input().split(" ")
A = a * int(b)
B = b * int(a)
print(sorted([A, B])[0])

Verdicts: Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b  =map(int,input().split())
if a >= b:
  print(str(a) * b)
else:
  print(str(b) * a)

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

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
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

L, R = map(str,input().split())
list = [L, R]
sorted(list)
print(list[0])


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) 

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)


Verdicts: Runtime Error

Wrong Answer

Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
# 7 7
a, b = [xfor x in input().split()]
print(sorted([a * b, b * a])[-1])

a, b = [x for x in input().split()]
print(sorted([a * int(b), b * int(a)])[0])


Verdicts: Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b=map(int,input())
A=int(str(a)*b)
B=int(str(b)*a)
print(min(A,B))

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

a,b=map(int,input())
A=str(a)*b
B=str(b)*a
print(min(int(A),int(B)))

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

Verdicts: Runtime Error

Wrong Answer

Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a, b = input().split()

print ( str(a)*b if a >= b else str(b)*a) 

a, b = input().split()

print ( a*int(b) if int(a) <= int(b) else b*int(a)) 

Verdicts: Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
r=input()
k=r.split()

t1=t2=0
for i in range(k[2]):
    t1 += k[0]
for i in range(k[0]):
    t2 += k[2]
    
jj=[t1,t2]
jj.sort(reverse=True)
print(jj[0])

r = input()
k=r.split()



t1=t2=''

t1=k[0]*int(k[1])
t2=k[1]*int(k[0])



rr = [t1,t2]

rr.sort()

print(rr[0])

Verdicts: Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a, b = input().split()

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


a, b = input().split()

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


Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

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

if num[0] == num[1]:
  max = num[0]
  min = num[1]
else:
  max = max(num[0],num[1])
  min = min(num[0],num[1])
  
print(str(max)*min)

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

if num[0] == num[1]:
  max = num[0]
  min = num[1]
else:
  max = max(num[0],num[1])
  min = min(num[0],num[1])
  
print(str(min)*max)

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

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

if a < b:	print(str(a+'0') * b )
else:	print(str(b+'0') * a )

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

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

Verdicts: Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
# -*- coding: utf-8 -*-
a,b = list(map(int, input().split()))
print(max(str(a)*b, str(b)*a))

# -*- coding: utf-8 -*-
a,b = list(map(int, input().split()))
print(min(str(a)*b, str(b)*a))

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
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)
  

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)

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b=map(int,input().split())
A=str(a)*b
B=str(b)*a
if len(A)>len(B):
  print(B)
elif len(B)>len(A):
  print(A)
else:
  for i in range(len(A)):
    if int(A[i])>int(B[i]):
      print(A)
    elif int(A[i])<int(B[i]):
      print(B)
  print(A)

a,b=map(int,input().split())
A=str(a)*b
B=str(b)*a
if len(A)>len(B):
  print(B)
elif len(B)>len(A):
  print(A)
else:
  for i in range(len(A)):
    if int(A[i])>int(B[i]):
      print(B)
    elif int(A[i])<int(B[i]):
      print(A)
    if i==len(A)-1:
      print(A)

a,b=map(int,input().split())
A=str(a)*b
B=str(b)*a
for i in range(min(len(A),len(B))):
  if int(A[i])>int(B[i]):
    print(B)
    break
  elif int(A[i])<int(B[i]):
    print(A)
    break
  if i==min(len(A),len(B))-1:
    print(A)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
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)

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)

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
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)

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)

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

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

la = ''
lb = ''

for i in range(b):
    la += a
    lb += b

if a <= b:
    print(la)
else:
    print(lb)



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

la = ''
lb = ''

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

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

if a <= b:
    print(la)
else:
    print(lb)



Verdicts: Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

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

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

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

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


Verdicts: Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b = int(input())
ls = [str(a) * b, str(b) * a]
ls.sort()
print(ls[0])

a,b = map(int,input().split())
ls = [str(a) * b, str(b) * a]
ls.sort()
print(ls[0])

Verdicts: Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
c = input().split(" ")
a = int(c[0])
b = int(c[1])

a_column = []
if a <= b:
    for i in range(b):
        a_column.append(a)
    print(a_column)

b_column = []
if b < a:
    for i in range(a):
        b_column.append(b)
    print(b_column)

c = input().split(" ")
a = int(c[0])
b = int(c[1])

a_ans = 0
if a <= b:
    for i in range(b):
        a_ans += a * (10 ** i)
    print(a_ans)

b_ans = 0
if b < a:
    for i in range(a):
        b_ans += b * (10 ** i)
    print(b_ans)

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a, b = input().split()
print(a * int(b) if a * int(b) > b * int(a) else b * int(a))


a, b = input().split()
print(a * int(b) if a * int(b) < b * int(a) else b * int(a))


Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

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

p = ""
q = ""

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

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

lst = [p, q]

sorted(lst)
print(lst[0])


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

p = ""
q = ""

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

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

list = [p, q]

sorted(list)
print(list[0])

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

p = ""
q = ""

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

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

lst = [p, q]

lst = sorted(lst)

print(lst[0])


Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
s_list = list(map(int, input().split()))
final_list = [(int(str(s_list[0]) * s_list[1]))]
final_list.append(int(str(s_list[1]) * s_list[0]))
final_list.sort()
print(final_list[0])


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

final_list = [(str(s_list[0]) * s_list[1])]
final_list.append(str(s_list[1]) * s_list[0])
final_list.sort()
print(final_list[0])


Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

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

X = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Y = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

for i in range(b):
    X[i] = str(a)
for j in range(a):
    Y[j] = str(b)
print(X)
print(Y)
for k in range(9):
    if int(X[k]) < int(Y[k]):
        ｎX = [e for e in X if e != 0]
        print(''.join(nX))
        break
    elif int(X[k]) > int(Y[k]):
        ｎY = [e for e in Y if e != 0]
        print(''.join(nY))
        break
    else:
        if k == 8:
            ｎX = [e for e in X if e != 0]
            print(''.join(nX))

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

X = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Y = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

for i in range(b):
    X[i] = str(a)
for j in range(a):
    Y[j] = str(b)

for k in range(9):
    if int(X[k]) < int(Y[k]):
        ｎX = [e for e in X if e != 0]
        print(''.join(nX))
        break
    elif int(X[k]) > int(Y[k]):
        ｎY = [e for e in Y if e != 0]
        print(''.join(nY))
        break
    else:
        if k == 8:
            ｎX = [e for e in X if e != 0]
            print(''.join(nX))

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
n, m = (input().split())
m=int(m)
if 1 <= int(n) <=9 and 1<=int(m)<=9:
    print(n*m)

n, m = (input().split())
n=int(n)
m=int(m)
if n>m:
    m=str(m)
    print(m*n)
else:
    n=str(n)
    print(n*m)

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
#coding:utf-8

n = int(input())
nums = map(int, input().split(' '))

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

#coding:utf-8

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


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

Verdicts: Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
_,a,b=sorted(input())[1:];print(a*int(b))

_,a,b=sorted(input());print(a*int(b))

Verdicts: Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b=input().split()
w=[a*int(b),b*int(a)]
sorted(w)
print(w[0])

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

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a, b = map(int,input().split())
if a >= b:
  a = str(a)a
  print(a*b)
else:
  b = str(b)
  print(b*a)

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

Verdicts: Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a, b = map(int, input().split())
if a >= b:
  print(b*((10**a -1)/9))
else:
  print(a*((10**b -1)/9))
  

a, b = input().split()
A = a*int(b)
B = b*int(a)
print(min(A, B))

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a, b = input().split()
x, y = int(a*int(b)), int(b*int(a))
if x >= y:
  print(y)
else:
  print(x)

a, b = input().split()
x, y = a*int(b), b*int(a)
L = len(y) if len(x) >= len(y) else len(x)
for l in range(L):
    if int(x[l]) > int(y[l]):
        print(y)
        break
    elif int(x[l]) < int(y[l]):
        print(x)
        break
else:
    if len(x) >= len(y):
        print(y)
    else:
        print(x)

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a, b = map(int, input().split())
a_ = int(str(a)*b)
b_ = int(str(b)*a)
if len(str(a_)) > len(str(b_)):
    print(b_)
elif len(str(a_)) == len(str(b_)):
    print(min(a_, b_))
else:
    print(a_)

import sys

a, b = map(int, input().split())
a_ = int(str(a)*b)
b_ = int(str(b)*a)
la = len(str(a_))
lb = len(str(b_))
if a_ == b_:
    print(a_)
    sys.exit()
for i in range(min(la, lb)):
    ai = str(a_)[i]
    bi = str(b_)[i]
    if ai > bi:
        print(b_)
        sys.exit()
    elif ai < bi:
        print(a_)
        sys.exit()

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b = input().split()
A = a * int(b)
B = b * int(a)

lis=[A,B]
true_list = lis.sort(reverse=True)
print(true_list[0])

a,b = input().split()
A = int(a * int(b))
B = int(b * int(a))

lis=[A,B]
true_list = lis.sort()
print(str(true_list[0]))

a,b = input().split()
A = a * int(b)
B = b * int(a)

lis=[A,B]
true_list = lis.sort()
print(true_list[0])

a,b = input().split()
A = int(a * int(b))
B = int(b * int(a))

if A >= B:
    print(str(A))
else:
    print(str(B))

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

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

a = u[0];
b = u[2];
at = int(a)
bt = int(b)

x = at*b
y = bt*a

if(x < y)
{
  print(x)
}
else
{
 print(y)
}

u = input()

a = u[0];
b = u[2];
at = int(a)
bt = int(b)

x = b*at
y = a*bt

if x <= y:
  print(x)

else:
 print(y)


Verdicts: Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a, b = map(int, input().split())
if a >= b:
    print(str(a) * b)
else:
    print(str(b) * a)

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

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

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

ab = str(str(a) * b)
ba = str(str(b) * a)

print(sorted([ab, ba]))
print(sorted([ab, ba])[0])


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

ab = str(str(a) * b)
ba = str(str(b) * a)

print(sorted([ab, ba])[0])


Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b=map(int,input().split())
a_=a*b
b_=b*a
s=[a_,b_]
s.sort()
print(s[0])

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

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
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)
        



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)
        



Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a, b = map(int,input().split())
A = list(str(a)*b,) B = list(str(b)*a)
C = max(len(A),len(B))
for i in range(C)
  if A[i] > B[i]:
  　　　　print(str(B))
         break
  elif B[i] > A[i]:
         print(str(A))
         break
  

a, b = map(int,input().split())
A = list(str(a)*b,) B = list(str(b)*a)
C = max(len(A),len(B))
for i in range(C)
  if A[i] > B[i]:
  　　　　print(str(B))
         break
  elif B[i] > A[i]:
         print(str(A))
         break

a, b = map(int,input().split())
A = list(str(a)*b,), B = list(str(b)*a)
C = max(len(A),len(B))
for i in range(C)
  if A[i] > B[i]:
  　　　　print(str(B))
         break
  elif B[i] > A[i]:
         print(str(A))
         break

a,b = map(int,input().split())
C = min(a,b)
D = max(a,b)
print(str(C)*D)

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a,b=map(int,ipnut().split())
print(str(min(int(a),int(b)))*max(int(a),int(b)))

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


Verdicts: Runtime Error

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a, b = map(int, input().split())
c = max(a, b)
d = min(a, b)
ans = str(c)*d
print(ans)

a, b = map(int, input().split())
c = max(a, b)
d = min(a, b)
ans = str(d)*c
print(ans)

Verdicts: Wrong Answer

Accepted
Problem: Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?

Submission attempts (in order):
a = sorted(input().split())
print(a[0] * a[1]

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

Verdicts: Runtime Error

Accepted