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):
import sys


def solve(inp):
    (a, b) = inp.readline().strip().split(' ')

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

    return str(max(ab, ba))


def main():
    result = solve(sys.stdin)
    if result:
        print(result)


if __name__ == '__main__':
    main()


import sys


def solve(inp):
    (a, b) = inp.readline().strip().split(' ')

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

    return str(min(ab, ba))


def main():
    result = solve(sys.stdin)
    if result:
        print(result)


if __name__ == '__main__':
    main()


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

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

a = list(map(str, input().split()))
 
if a[0] <= a[1]:
    print(a[0] * int(a[1]))
else:
    print(a[1] * int(a[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):
M, N = map(int, input().split())

if M > N:
  body = N
  numm = M
else:
  body = M
  numm = N

ret = ''
for i in numm:
  ret += str(body)
print(ret)

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

if M > N:
  body = N
  numm = M
else:
  body = M
  numm = N

ret = ''
for i in range(numm):
  ret += str(body)
print(ret)

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()
aa = a * int(b)
bb = b * int(a)
print(aa if len(aa) < len(bb) else bb)

a, b = input().split()
aa = a * int(b)
bb = b * int(a)
words = [aa, bb]
words.sort()
print(words[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_str, b_str = input.split()
a, b = int(a_str), int(b_str)

A = a_str*b
B = b_str*a

print(min(A, B))

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

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):
    Yes=[str(A)]*A

elif (A>B):
    Yes=[str(B)]*B
else:
    Yes=[str(A)]*A

s = ''.join(Yes)
print(s)

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

    Yes=[A]*A

    print(Yes)
elif (A>B):
    Yes=[B]*B
    print(Yes)
else:
    Yes=[A]*A
    print(Yes)

A, B = map(int, input().split())
if (A==B):
    Yes=[str(A)]*A

elif (A>B):
    Yes=[str(B)]*A
else:
    Yes=[str(A)]*B

s = ''.join(Yes)
print(s)

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):
N,M = (int(x) for x in input().split())

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

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

N,M = input().split()

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

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

N,M = input().split()

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

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

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

a, b = map(int, input().split())
ans = min(str(a) * b, str(b) * a)
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):
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: 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 = int(input())
L = len(str(N))
B = int(str(N)[0])
c = 0
for i in range(1,N+1):
    I = str(i)
    l = len(I)
    a,b = int(I[0]),int(I[l-1])
    if a == 0 or b == 0:
        continue
    else:
        if a == b:
            c += 1
        for m in range(max(L-2,0)):
            c += 10**m
        if L == 1:
            continue
        if b > B:
            continue
        elif b < B:
            c += 10**(L-2)
        elif L > 2:
            c += int(str(N)[1:L-1])
        elif L == 2:
            c += 1
print(c)

a,b = input().split()
A,B = min(int(a),int(b)),max(int(a),int(b))
print(int(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(input().split())
ast = a * int(b)
bst = b * int(a)
print(ast if ast < bst else bst)

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

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

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

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 = [int(i) for i in input().split()]
A = max(a,b)
B = max(a,b)
a_list=[]
for k in range(b):
	a_list.append(a)
print(''.join(map(str,a_list))

a,b = [int(i) for i in input().split()]
A = max(a,b)
B = min(a,b)
a_list=[]
for _ in range(A):
	a_list.append(B)
print(''.join(map(str,a_list)))

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(str,input().split())
if a<=b:
  s=a
  for _ in range(b-1):
    s+=a
  print (s)
else:
  s=b
  for _ in range(a-1):
    s+=b
  print(s)
  

a,b=map(str,input().split())
if int(a)<=int(b):
  s=a
  for i in range(b-1):
    s+=a
  print (s)
else:
  s=b
  for j in range(a-1):
    s+=b
  print(s)
  


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


a,b=map(str,input().split())
if int(a)<=int(b):
  s=a
  for i in range(int(b)-1):
    s+=a
  print (s)
else:
  s=b
  for j in range(int(a)-1):
    s+=b
  print(s)
  

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=list(map(lambda x:x,input().split()))
if(a[1]>a[0]):
  print(str(a[0])*a[1])
else:
  print(str(a[1])*a[0])

a=list(map(lambda x:x,input(),split()))
if(a[1]>a[0]):
  print(str(a[0])*a[1])
else:
  print(str(a[1])*a[0])

a=list(map(lambda x:x,input().split()))
if(a[1]>a[0]):
  print(a[0]*int(a[1]))
else:
  print(a[1]*int(a[0]))

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

a,b=input().split()
A=str(a)*int(b)
B=str(b)*int(a)
if(str(B)<=str(A)):
  print(B)
else:
  print(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())
l=[]
if a<b:
  for i in range(a):
    l.append(b)
    l=[str(i) for i in l]
    L=''.join(l)
	print(L)
else:
   for i in range(b):
    l.append(a)
    l=[str(i) for i in l]
    L=''.join(l)
	print(L)
  

a,b=map(int,input().split())
l=[]
if a<b:
  for i in range(a):
    l.append(b)
    l=[str(i) for i in l]
    L=''.join(l)
	print(L)
else:
   for i in range(b):
    l.append(a)
     l=[str(i) for i in l]
    L=''.join(l)
	print(L)
  

a,b=map(int,input().split())
l=[]
if a<b:
  for i in range(a):
    l.append(b)
    L=''.join(l)
	print(L)
else:
   for i in range(b):
    l.append(a)
    L=''.join(l)
	print(L)
  

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

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):
n,m =int(input()).strip().split()
if(n>m):
  print(m*(str(n)))

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

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

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

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

a,b=map(int,input().split())
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):
def execute(key: int, base: str) -> str:
  s = ""
  for i in range(key):
    s += str(base)
  return s

a, b = input().split()
c = [execute(a, b), execute(b, a)]
print(sorted(c)[0])

def execute(key: int, base: str) -> str:
  s = ""
  for i in range(key):
    s += str(base)
  return s

a, b = input().split()
c = [execute(int(a), b), execute(int(b), a)]
print(sorted(c)[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:
  string(a)*b
  print(string(a)*b)
else:
  print(string(b)*a)

a,b=map(int, input().split())
if a<b:
    str(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):
tmp = input().split()
a = int(tmp[0])
b = int(tmp[1])

ans_a = a
ans_b = b
for i in range(b-1):
 ans_a = (ans_a*10) + a

for i in range(a-1):
 ans_b =(ans_b*10) + b

if ans_a < ans_b:
 print(ans_a)
elif ans_a > ans_b:
 print(ans_b)
else:
 print(ans_a)

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

ans_a = a
ans_b = b
for i in range(b-1):
 ans_a =(ans_a*10) + a

for i in range(a-1):
 ans_b =(ans_b*10) + b

if ans_a == ans_b:
 print(ans_a)
else:
 list = [str(ans_a),str(ans_b)]
 list.sort()
 print(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 = input().split()
an, bn = int(a), int(b)

ab = a * bn
ba = b * an

if ab >= ba:
  print(ab)
else:
  print(ba)


a, b = input().split()
an, bn = int(a), int(b)
 
ab = a * bn
ba = b * an
 
if ab >= ba:
  print(ba)
else:
  print(ab)

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 = int(a * int(a))
y = int(b * int(b))
print(min(x, y))


a, b = input().split()
x = [a * int(b), b * int(a)]
x.sort()
print(x[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())
c=str("a")*b
d=str("b")*a
if a>=b:
    print(d)
else:
    print(c)


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

if x>y:
  print(str(y)*x)
elif x<y:
  print(str(x)*y)
else:
  print(str(x)*y)

def main():
  x=int(input())
  y=int(input())
  
  if x>y:
    print(str(y)*x)
  elif x<y:
    print(str(x)*y)
  else:
    print(str(x)*y)
main()

def main():
  x=int(input())
  y=int(input())
  
  if x>y:
    print(str(y)*x)
  elif x<y:
    print(str(x)*y)
  else:
    print(str(x)*y)
main()
    

def main():
    x, y = [int(i) for i in input().split()]
    if x > y:
        print(str(y) * x)
    elif x < y:
        print(str(x) * y)
    else:
        print(str(x) * y)
main()

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=input().split()
if A>=B:
  print(A*int(B))
else:
  print(B*int(A))

A,B=input().split()
if A<=B:
  print(A*int(B))
else:
  print(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=input()
b=input()
pre=a*int(b)
post=b*int(a)
print(pre if pre<=post else post)

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

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)
for(int i=0; i<a; i++):
    X+="A"
for(int j=0; j<b; j++):
    Y+="B"

if a<b:
    print(X)
if a>b:
    print(Y)


a , b =map(int(),input().split())
A=str(a)
B=str(b)
for i in a:
    X+="A"
for j in b:
    Y+="B"

if a<b:
    print(X)
if a>b:
    print(Y)


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


Verdicts: 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):
n = int(input())
p = list(map(int,input().split()))
#n = 5
#p = [4,2,5,1,3]
maxcnt = 1
cnt = 1
for i in range(n):
    box = 0
    cnt = 1
    box = p[i]
    if n - i < maxcnt :
        break

    for j in range(i + 1 , n ):
        if i < j and box >= p[j]:
            box = p[j]
            cnt += 1
            if maxcnt < cnt :
                maxcnt = cnt
            
print(maxcnt)


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

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([str(a)] * a)
B = ''.join([str(b)] * b)

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

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


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

a,b = input().split()
print(a*int(b)if a<b 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())
c = ''
if a >= b:
  for i in range(b):
    c += str(a)
else:
  for i in range(a):
    c += str(b)
    
print(c)
    


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(int(c))

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))


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())
s = max(a,b)
t = min(a,b)
k = 0
for i in range(1,s+1):
  k += t*(10**i)
  
  
print(k)

a , b = map(int,input().split())
s = max(a,b)
t = min(a,b)
k = 0
for i in range(0,s+1):
  k += t*(10**i)
  
  
print(k)


a , b = map(int,input().split())
s = max(a,b)
t = min(a,b)
k = 0
for i in range(0,s):
  k += t*(10**i)
  
  
print(k)


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

a,b=(int(x) for x in 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=map(int,input().split())

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

print(str(s)*b)

#!/usr/bin/env python3

def solve(a,b):
  str1 = str(a)*b
  str2 = str(b)*a
  if str1 < str2:
    return str1
  else:
    return str2



def main():
  a,b = map(int,input().split())
  print(solve(a,b))
  return

if __name__ == '__main__':
  main()


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())

num1 = int(a * int(b))
num2 = int(b * int(a))

if num1 >num2:
    print(num2)

if num1 <num2:
    print(num1)
    
else:
    print(num1)

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

num1 = int(a * int(b))
num2 = int(b * int(a))

if num1 >num2:
    print(num2)

if num1 <num2:
    print(num1)



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

num1 = a * int(b)
num2 = b * int(a)

num = sorted([num1, num2])
print(num[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):
a,b=map(int,input().split())
ans=""
if a>=b:
    for i in range(b):
        ans+=str(a)
else:
    for i in range(a):
        ans+=str(b)
print(ans)

a,b=map(int,input().split())
ans=""
if a>=b:
    for i in range(a):
        ans+=str(b)
else:
    for i in range(b):
        ans+=str(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):
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])



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])


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())
s.append(str(a)*b)
s.append(str(b)*a)
s.sort()
print(s[0])

a,b=map(int,input().split())
s=[]
s.append(str(a)*b)
s.append(str(b)*a)
s.sort()
print(s[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()

bigA = a*int(b)
bigB = b*int(a)

if bigA < bigB:
    print(bigA)
elif bigA = bigB:
    print(bigA)
else:
    print(bigB)

a, b = input().split()

bigA = a*int(b)
bigB = b*int(a)

if bigA < bigB:
    print(bigA)
elif bigA == bigB:
    print(bigA)
else:
    print(bigB)

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("a"*b)
elif a>b:
    print("b"*a)
elif a<b:
    print("a"*b)



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)


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

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

a,b=input().split()
if a<b:
  print(a*int(b))
else:
  print(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())
la = []
lb = []
i = 0
map_la = map(str, la)
map_lb = map(str, lb)
while i <= b:
  la.append(a)
  map_la = ''.join(map_la)
  i += 1
while i <= a:
  la.append(b)
  map_lb = ''.join(map_lb)
  i += 1
if map_la <= map_lb:
  print(map_la)
else:
  print(map_lb)

a,b = map(str,input().split())
if a > b:
  print(b*int(a))
else:
  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=map(int,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):
,b = map(int,input().split())
s = 0
if a <= b:
    for i in range(0,b):
        s += a*(10**i)

else:
    for i in range(0,a):
        s += b*(10**i)

print(s)

a,b = map(int,input().split())
s = 0
if a <= b:
    for i in range(0,b):
        s += a*(10**i)

else:
    for i in range(0,a):
        s += b*(10**i)

print(s)

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())
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):
def repeat_string(x, y):
    """Return the digit x repeated y times."""
    single_string = str(x)
    repeat_string = single_string*y
    return repeat_string


def compare_strings(a, b):
    if a>b: return(repeat_string(b, a))
    return(repeat_string(a, b))


if __name__ == "__main__":
    test1 = "4 3"
    test2 = "7 7"
    test = test2
    test_input = map(int, intput().split())
    print(compare_strings(*test_input))


def repeat_string(x, y):
    """Return the digit x repeated y times."""
    single_string = str(x)
    repeat_string = single_string*y
    return repeat_string


def compare_strings(a, b):
    if a>b: return(repeat_string(b, a))
    return(repeat_string(a, b))


if __name__ == "__main__":
    test1 = "4 3"
    test2 = "7 7"
    test = test2
    test_input = map(int, input().split())
    print(compare_strings(*test_input))


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().split(' ')
n = int(n)
m = int(m)
nn = 0
mm = 0
for i in range(m):
	nn = nn + m * pow(10, i)
for i in range(n):
	mm = mm + n * pow(10, i)    
if n < m:
  print(mm)
else:
  print(nn)

n, m=input().split(' ')
n = int(n)
m = int(m)
nn = 0
mm = 0
for i in range(m):
	nn = nn + n * pow(10, i)
for i in range(n):
	mm = mm + m * pow(10, i)    
if n < m:
  print(nn)
else:
  print(mm)

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()))
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))

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)))


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)))

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


Verdicts: 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())
if a==min(a,b);
  s=str(a)*b
  print(int(s))
else:  
  s=str(b)*a
  print(int(s))

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


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())
num1 = [a]*b
num2 = [b]*a
num1 = [str(i) for i in num1]
num2 = [str(i) for i in num2]
num1 = int(''.join(num1))
num2 = int(''.join(num2))
print(min(num1,num2))


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

a1 = 0
for i in range(b):
  a1 = a1*10 + a
  
b1 = 0
for i in range(a):
  b1 = b1*10 + b
  
print(min(a1,b1))

a,b = map(int,input().split())
if a>b: a,b = b,a
ans = 0
for i in range(b):
  ans = ans*10 + 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):
import numpy as np

a, b = input().split()

s = []
s.append(a*int(b))
s.append(b*int(a))

s = np.sort(s)

print(s)

import numpy as np
 
a, b = input().split()
 
s = []
s.append(a*int(b))
s.append(b*int(a))
 
s = np.sort(s)
 
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=(int(x) for x in input().split())
A=max(a,b)
B=min(a,b)
l=[]
for i in range(B):
  l.append(str(A))
o="".join(l)
print(o)

a,b=(int(x) for x in input().split())
la=[]
for i in range(b):
  la.append(str(a))
ao="".join(la)
lb=[]
for i in range(a):
  lb.append(str(b))
bo="".join(lb)
l=[]
l.append(ao)
l.append(bo)
l.sort()
print(l[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())

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

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

for i in range(max(a,b)):
    ans += (str(min(a,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())


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)


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)


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)
nlist = (A, B)
sorted(nlist)
if A != B:
    print(nlist[0])
else:
    print(A)


a, b = map(int, input().split())
A = int(str(a) * b)
B = int(str(b) * a)
nlist = (A, B)
newlist = sorted(nlist)
if A != B:
    print(newlist[0])
else:
    print(A)


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

a, b = map(int, input().split())
A = list(str(a) * b)
B = list(str(b) * a)
if A[0] >= b[0]:
    print(str(a)*b)
else:
    print(str(b)*a)

a, b = map(int, input().split())
A = int(str(a) * b)
B = int(str(b) * a)
nlist = (A, B)
sorted(nlist)
print(nlist[0])

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

l = ['{}'.format(a)*b, '{}'.format(b)*a]
l.sort()
print(l[0])

Verdicts: Wrong Answer

Wrong Answer

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):
S = [input().split()]
S.sort()
print(S[0])

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


a,b=input().split()

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

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

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


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


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

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


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


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


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


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

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


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


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

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


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

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


Verdicts: Wrong Answer

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Wrong Answer

Runtime Error

Runtime Error

Wrong Answer

Runtime Error

Runtime Error

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

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

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

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

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

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

A = int(a * int(b))
B = int(b + int(a))

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

T = input().split()

a = T[0]
b = T[1]

A = int(a * int(b))
B = int(b + int(a))

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

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

A = int(a * int(b))
B = int(b + int(a))

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

T = input().split()

a = T[0]
b = T[1]

A = int(a * int(b))
B = int(b * int(a))

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


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

A = int(a * int(b))
B = int(b * int(a))

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

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

A = int(a*(int(b)))
B = int(b*(int(a)))

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

Verdicts: Runtime Error

Runtime Error

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

a, b = map(int,input().split())
a_b = str(a)*b
b_a = str(b)*a
ab_list = [a_b,b_a]
ab_list.sort()
print(ab_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 = list(map(int,input().split()))
if a <= b:
  print(a)*b
else:
  print(b)*a

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


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()
a_int = int(a)
b_int = int(b)
ab = int(a*b_int)
ba = int(b*a_int)
if ab >= ba:
    print(ba)
elif ab <= ba:
    print(ab)

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

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):
M = input().split()
i = 0
alfa = ''
if M[0] > M[1]:
    for i in range(int(M[1])):
       alfa += str(M[0])
    print(alfa)
elif M[0] < M[1]:    
    for i in range(int(M[0])):
       alfa += str(M[1])
    print(alfa)
elif M[0] == M[1]:    
    for i in range(int(M[0])):
       alfa += str(M[1])
    print(alfa)
else:
    print('')

M = input().split()
i = 0
a = None
b = None
for i in range(int(M[0])):
    a += str(M[1])
alfa = int(a)
for i in range(M[1]):
    b += str(M[0])
beta = int(b)
delta = min(a,b)
print(delta)

M = input().split()
i = 0
a = ''
b = ''
c = ''
if M[0] > M[1]:
    for i in range(int(M[1])):
        a += str(M[0])
    print(a)
elif M[0] < M[1]:    
    for i in range(int(M[0])):
        b += str(M[1])
    print(b)
elif M[0] == M[1]:    
    for i in range(int(M[0])):
        c += str(M[1])
    print(c)

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)

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

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(c[0])

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]))

Verdicts: Wrong Answer

Runtime Error

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):
num=[int(e) for e in input().split()]
if num[0]>=num[1]:
  print(num[1]*(10**num[0]))
else:
  print(num[0]*(10**num[1]))

num=[int(e) for e in input().split()]
A=str(num[0])
B=str(num[1])
if num[0]>=num[1]:
  for i in range(num[0]-1):
    B+=str(num[1])
  print(B)
else:
  for i in range(num[1]-1):
	A+=str(num[0])
  print(A)

num=[int(e) for e in input().split()]
A=str(num[0])
B = str(num[1])

if num[0]>=num[1]:
  for i in range(num[0]-1):
    B+=str(num[1])
  print(B)
else:
  for i in range(num[1]-1):
      A+=str(num[0])
  print(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())
A = ""
B = ""
for i in range(0,b):
    A += str(b)
for j in range(0,a):
    B += str(a)
print(sorted([A,B])[0])

a,b = map(int,input().split())
A = ""
B = ""
for i in range(0,b):
    A += str(a)
for j in range(0,a):
    B += str(b)
print(sorted([A,B])[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())
print(str(a)*b if a>=b else str(b)*a)

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

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

a,b = map(int,input().split())
min_a=str(a)*b
min_b=str(b)*a
print(min(min_a, min_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 = list(map(int, input().split()))
print(a,b)

if a > b:
    ans = ''
    for target_list in range(a):
        ans = ans + str(b)

    print(ans)

if b > a:
    ans = ''
    for target_list in range(b):
        ans = ans + str(a)

    print(ans)
    

if b == a:
ans = ''
    for target_list in range(b):
        ans = ans + str(a)

    print(ans)


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

if a > b:
    ans = ''
    for target_list in range(a):
        ans = ans + str(b)

    print(ans)

if b > a:
    ans = ''
    for target_list in range(b):
        ans = ans + str(a)

    print(ans)
    

if b == a:
ans = ''
    for target_list in range(b):
        ans = ans + str(a)

    print(ans)


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

if a > b:
    ans = ''
    for target_list in range(a):
        ans = ans + str(b)

    print(ans)

if b > a:
    ans = ''
    for target_list in range(b):
        ans = ans + str(a)

    print(ans)
    

if b == a:
    ans = ''
    for target_list in range(b):
        ans = ans + str(a)

    print(ans)


Verdicts: 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 = input().split()
list = [a, b]
list.sort()
print(int(list[0]))

A,B = input().split()
a = int(A)
b = int(B)
out = ''
if a > b:
    for i in range(a):
        out += B
else:
    for i in range(b):
        out += A
print(out)

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)

la=len(A)
lb=len(B)

if la<lb:
    l=la
else:
    l=lb

for i in range(l):
    if int(A[i])-int(B[i])>0:
        print(B)
        break
    elif A[i]==B[i]:
        pass
    else:
        print(A)
        break

print(A)


a,b=input().split()

li=[a*int(b),b*int(a)]
li.sort()

print(li[0])


Verdicts: Wrong Answer

Accepted