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 = list(map(int,input().split()))
para_a = str(B)
para_b = str(A)

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

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

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

print(N[0])


A,B = list(map(int,input().split()))
para_a = str(B)
para_b = str(A)

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

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

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

print(N[0])


A,B = list(map(int,input().split()))
para_a = str(B)
para_b = str(A)

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

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

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


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 B < A:
  A,B=B,A
for i in range B;
 print(A, end="")
print()

A,B=map(int,input().split())
if B < A:
  A,B=B,A
for i in range(B):
 print(A, end="")
print()

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):
Input = input().split()
Input[0] = int(Input[0])
Input[1] + int(Input[1])

if Input[0] >= Input[1]:
  print(str(Input[1])*Input[0])

else:
  print(str(Input[0])*Input[1])

Input = input().spilit()
Input[0] = int(Input[0])
Input[1] = int(Input[1])

i = 0

if Input[0] > Input[1]:
  print(str(Input[0])*Input[1])

elif Input[1] > Input[0]:
  print(str(Input[1])*Input[0])

else:
  print(str(Input[0])*Input[0])
  
  

Input = input().split()
Input[0] = int(Input[0])
Input[1] = int(Input[1])
 
if Input[0] >= Input[1]:
  print(str(Input[1])*Input[0])
  
else:
  print(str(Input[0])*Input[1])

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

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

aa = str(1000)
bb = str(111)

if aa <= bb:
  print(aa)
else:
  print(bb)

a, b = input().split()

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

if aa <= bb:
  print(aa)
else:
  print(bb)

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)＊b
b1=str(b)＊a

if a>=b:
  print(b1)
elif a<b:
  print(a1)

li = input().split()

if li[0]>=li[1]:
  print(li[1]＊int(li[0]))
else:
  print(li[0]＊int(li[1]))


a,b = input().split()

if a>=b:
  print(b＊int(a))
else:
  print(a＊int(b))


li = input().split()

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


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

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

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

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

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

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

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):
inp = input().split("")
lis = [,]
for i in range(inp[0]):
  lis[1] += inp[1]
for i in range(inp[1]):
  lis[0] += inp[0]
lis.sort()
print(lis[0])

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

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

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

txt = input().split(" ")
txt.sort
print(a[0])

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

Verdicts: Runtime Error

Wrong Answer

Wrong Answer

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


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

if a < b:
    print(str(a)*b)
elif 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):
n, m = map(int,input().strip().split())
for i in range(0, n):
    print(m,end='')

n, m = map(int,input().strip().split())
temp = int('{}'.format(n)*m)
m = int('{}'.format(m)*n)
temp = str(temp)
m = str(m)
if temp==m:
    print(temp)
elif temp[0]<m[0]:
    print(temp)
else:
    print(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):
a,b=map(int, input().split())
A=str(a);B=str(b);
if a>=b:
    print(A*b)
else :
    print(B*a)

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

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


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=[v for v in input().split()]
u=int(a[0])
for i in range (0,u):
    print(a[1],end='')

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


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

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

ans = min(s1,s2)

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


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

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

ans = min(s1,s2)
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())
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):
n,m = map(int,input().split())

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

print(a if n <= m else b)

import itertools
n,m = map(int,input().split())
a = b = ''
for _ in range(m):
    a += str(n)
for _ in range(n):
    b += str(m)
ans = [a,b]
print(list(itertools.permutations(ans))[0][0])

n,m = map(int,input().split())
a = b = ''
for _ in range(m):
    a += str(n)
for _ in range(n):
    b += str(m)

print(a if n <= m else b)

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

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

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

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

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

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

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=[int(i) for i in input().split()]
ans=""
if n>=m:
  for i in range(n):
    ans+=m
else:
  for i in range(m):
    ans+=n
print(ans)

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


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

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


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

a,b=input().split()
if int(a)>int(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(input().split())
num_a = int(a)
num_b = int(b)

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

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

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

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

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

a, b = list(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):
from sys import stdin
def solve():
  a,b=map(int,stdin.readline().split())
  sa='a'*b
  sb='b'*a
  print(min(sa,sb))
solve()

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


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



def input_int():
    return int(input())



def int1(x):
    return int(x) - 1



def input_to_int_map():
    return map(int, input().split())



def input_to_int_tuple():
    return tuple(map(int, input().split()))



def input_to_int_tuple_minus1():
    return tuple(map(int1, input().split()))


def main():
    a, b = input_to_int_map()
    import itertools
    _a = itertools.repeat(str(a), b)
    _b = itertools.repeat(str(b), a)
    ret = _b
    if _a < _b:
        ret = _a

    return ret


if __name__ == "__main__":
    print(main())


# -*- coding: utf-8 -*-



def input_int():
    return int(input())



def int1(x):
    return int(x) - 1



def input_to_int_map():
    return map(int, input().split())



def input_to_int_tuple():
    return tuple(map(int, input().split()))



def input_to_int_tuple_minus1():
    return tuple(map(int1, input().split()))


def main():
    a, b = input_to_int_map()
    import itertools
    _a = "".join(itertools.repeat(str(a), b))
    _b = "".join(itertools.repeat(str(b), a))
    ret = _b
    if _a < _b:
        ret = _a

    return ret


if __name__ == "__main__":
    print(main())


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

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

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:
  tmp=a
  a=b
  b=tmp
return a*((10**b-1)/9)

a,b=map(int,input().split())
if a>=b:
  tmp=a
  a=b
  b=tmp
print(a*((10**(b+1)-1)//9))

a,b=map(int,input().split())
if a>=b:
  tmp=a
  a=b
  b=tmp
print(a*((10**b-1)//9))

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):
data = input().split()

a = data[0]
b = data[1]

ans = min(a, b) * max(a, b)

print(ans)


data = input().split()
 
a = data[0]
b = data[1]
 
ans = min(a, b) * int(max(a, 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):
a,b = map(int, input().split())

str_a = [a] * b
str_b = [b] * a

if str_a > str_b:
    print(*str_b)
else:
    print(*str_a)

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

str_a = [a] * a
str_b = [b] * b

if str_a > str_b:
    print(*str_b)
else:
    print(*str_a)

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

str_a = [a] * b
str_b = [b] * a

if str_a > str_b:
    print(''.join(map(str, str_b)))
else:
    print(''.join(map(str, str_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())

a="";b=""
a=str(A)*B;b=str(B)*A
if A=<B:
    print(a)
elif A>B:
    print(b)

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

a="";b=""
a=str(A)*B;b=str(B)*A
if A<=B:
    print(a)
elif A>B:
    print(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()
 
X = 0
Y = 0

for i in b:
  X = 'X' + 'a'
  
for v in a:
  Y = 'Y' + 'b'
  
if 'X' < 'Y':
  print('X')
else:
  print('Y')

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

X = 0
Y = 0

list = [X,Y]

for i in b:
  X = X + 'a'
  
for v in a:
  Y = Y + 'b'
  
if 'X' < 'Y':
  print(X)
else:
  print(Y)

a , b =input().split()
 
if a <= b:
	for i in b:
    print(a*int(b))
 
else:
	for v in a:
	print(b*int(a))

a , b = map(int(),input().split())
 
X = 0
Y = 0

for i in b:
  X = 'X' + 'a'
  
for v in a:
  Y = 'Y' + 'b'
  
if 'X' <= 'Y':
  print('X')
else:
  print('Y')

a , b = map(int(),input().split())
 
X = 0
Y = 0
 
if a < b:
	for i in b:
		X = 'X' + 'a'
    print(X)
 
else:
	for v in a:
		Y = 'Y' + 'b'
	print(Y)

a , b = input().split()
 
X = 0
Y = 0

for i in b:
  X = 'X' + 'a'
  
for v in a:
  Y = 'Y' + 'b'
  
if 'X' < 'Y':
  print('X')
else:
  print('Y')

a , b = map(int(),input().split())
 
X = 0
Y = 0

for i in b:
  X = 'X' + 'a'
  
for v in a:
  Y = 'Y' + 'b'
  
if 'X' < 'Y':
  print(X)
else:
  print(Y)

a , b = input().split()
 
X = 0
Y = 0

for i in b:
  X = 'X' + 'a'
  
for v in a:
  Y = 'Y' + 'b'
  
if 'X' <= 'Y':
  print('X')
else:
  print('Y')

a , b = input().split()
 
X = 0
Y = 0

for i in b:
  X = 'X' + 'a'
  
for v in a:
  Y = 'Y' + 'b'
  
if 'X' < 'Y':
  print(X)
else:
  print(Y)

a , b = map(int(),input().split())
 
X = ''
Y = ''
 
if a < b:
	for i in b:
		X = 'X' + 'a'
    print(X)
 
else:
	for v in a:
		Y = 'Y' + 'b'
	print(Y)

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

if a <= b:
	for i in b:
    print(a*int(b))
 
else:
	for v in a:
	print(b*int(a))

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

X = 0
Y = 0

if a < b:
	for i in b:
		X = 'X' + 'a'
    print(X)

else:
	for v in a:
		Y = 'Y' + 'b'
	print(Y)

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

Verdicts: Wrong Answer

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Wrong Answer

Runtime Error

Wrong Answer

Wrong Answer

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())
A = int(str(a)**b)
B = int(str(b)**a)

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

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

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

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


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


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())
ss = []
ss.append(str(a) * b)
ss.append(str(b) * a)
print(sorted(ss))


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

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

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

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

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

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

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

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

if A > B:
    print(B)
elif A < B:
    print(A)
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 = input().split()
a_w = a * int(b)
b_w = b * int(a)

if a => b:
  print(b_w)
else:
  print(a_w)

a, b = input().split()
a_w = a * int(b)
b_w = b * int(a)

if a > b:
  print(b_w)
else:
  print(a_w)

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

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


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

a, b = input().split()
print(max(int(a*int(b)), int(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):
l=list(map(int,input().split()));print(min(l)*max(l))

l=list(map(int,input().split()));print(str(min(l))*max(l))

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


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

a, b = input().split()
a_str = a * int(b)
b_str = b * int(a)

if a_str < b_str:
  print(a_str)
else:
  print(b_str)


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:
  for i in range(a):
   	sum=a*pow(10,i)
  print(sum)
elif a<b:
  for i in range(b):
   	sum=a*pow(10,i)
  print(sum)
elif b<a:
  for i in range(a):
   	sum=b*pow(10,i)
  print(sum)

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

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=""
for i in range(int(a)):
    A=A+a
B=""
for i in range(int(b)):
    B=B+b
#print(A)
#
print(min(A,B))

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

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())
print(max(int(str(a)*b), int(str(b)*a)))

a, b = map(int, input().split())
print(max(int(str(a)*b), int(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):
import numpy as np
a,b = map(int,input().split())
if (a*10**b) > (b*10**a):
    print(np.ceil(a * (10**b + 10**(b-1) + 10**(b-2) + 10**(b-3) + 10**(b-4) + 10**(b-5) + 10**(b-6) + 10**(b-7) + 10**(b-8) + 10**(b-9))))
else:
    print(np.ceil(b * (10**a + 10**(a-1) + 10**(a-2) + 10**(a-3) + 10**(a-4) + 10**(a-5) + 10**(a-6) + 10**(a-7) + 10**(a-8) + 10**(a-9))))

import numpy as np
a,b = map(int,input().split())
if (a*10^b) > (b*10^a):
    print(np.ceil(a * (10^b + 10^(b-1) + 10^(b-2) + 10^(b-3) + 10^(b-4) + 10^(b-5) + 10^(b-6) + 10^(b-7) + 10^(b-8) + 10^(b-9))))
else:
    print(np.ceil(b * (10^a + 10^(a-1) + 10^(a-2) + 10^(a-3) + 10^(a-4) + 10^(a-5) + 10^(a-6) + 10^(a-7) + 10^(a-8) + 10^(a-9))))

import numpy as np
a,b = map(int,input().split())
if (a*10**b) > (b*10**a):
    print(int(a * (10**(b-1) + 10**(b-2) + 10**(b-3) + 10**(b-4) + 10**(b-5) + 10**(b-6) + 10**(b-7) + 10**(b-8) + 10**(b-9))))
else:
    print(int(b * (10**(a-1) + 10**(a-2) + 10**(a-3) + 10**(a-4) + 10**(a-5) + 10**(a-6) + 10**(a-7) + 10**(a-8) + 10**(a-9))))

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):
input_numbers = list(map(int,input().split()))
a = input_numbers[0]
b = input_numbers[1]
A = a
B = b
x = 0
y = 0
while A >= 0:
  x += 10 ** A * b
  A -= 1
while B >= 0:
  y += 10 ** B * a
  B -= 1
if x > y:
  ptint(x)
else:
  print(y)

a, b = input().split()
list1 = [a * int(b), b * int(a)]
L = sorted(list1)
print(L[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):
input_line=input().rstrip().slpit()
num1 = int(input_line[0])
num2 = int(input_line[1])

if (num1 > num2):
  print(str(num2)*num1)
elif (num1 < num2):
  print(str(num1)*num2)
elif (num1 == num2):
  print(str(num1)*num2)

input_line=input().rstrip().slpit()
num1 = int(input_line[0])
num2 = int(input_line[1])
list1 = []
list2 = []
for i in range (num2):
  list1.append(num1)
list_num1 = join(map(str, list1))
list_int_num1 = int(list_num1)

for i in range (num1):
  list2.append(num2)
list_num2 = join(map(str, list2))
list_int_num2 = int(list_num2)

if (list_int_num1 > list_int_num2):
  print(list_int_num2)
elif(list_int_num1 < list_int_num2):
  print(list_int_num1)
elif(list_int_num1 == list_int_num2):
  print(list_int_num1)

input_line=input().rstrip().slpit()
num1 = int(input_line[0])
num2 = int(input_line[1])
if (num1>num2):
  num = num2
elif(num1<num2):
  num = num1
elif(num1=num2):
  num = num1
count = num
for i in range(count):
  print(num)

input_line=input().rstrip().slpit()
num1 = int(input_line[0])
num2 = int(input_line[1])
list1 = []
list2 = []
if (num1 > num2):
  for i in range(num1):
    list1.append(num2)
  list_num1 = join(map(str, list1))
  list_int_num1 = int(list_num1)
  print(list_num_num1)
elif (num1 < num2):
  for j in range(num2):
    list1.append(num1)
  list_num2 = join(map(str, list2))
  list_int_num2 = int(list_num2)
  print(list_num_num2)
elif (num1 == num2):
  for k in range(num2):
    list1.append(num1)
  list_num2 = join(map(str, list2))
  list_int_num2 = int(list_num2)
  print(list_num_num2)

input_line=input().rstrip().slpit()
num1 = int(input_line[0])
num2 = int(input_line[1])
if (num1>num2):
  num = num2
elif(num<num2):
  num = num1
elif(num1=num2):
  num = num1
count = num
for i in range(count):
  print(num)

input_line=input().rstrip().split()
num1 = int(input_line[0])
num2 = int(input_line[1])
 
if (num1 > num2):
  print(str(num2)*num1)
elif (num1 < num2):
  print(str(num1)*num2)
elif (num1 == num2):
  print(str(num1)*num2)

Verdicts: Runtime Error

Runtime Error

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):
# B Comparing Strings

a, b = input().split()

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

print(s[0])

# B Comparing Strings

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

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

var1 = 0
var2 = 0

for i in range(a[1]):
    var1 = var1 * 10 + a[0]

for i in range(a[0]):
    var2 = var2 * 10 + a[1]

if var1 < var2:
    print(var1)
else:
    print(var2)


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

var1 = 0
var2 = 0

for i in range(a[1]):
    var1 = var1 * 10 + a[0]

for i in range(a[0]):
    var2 = var2 * 10 + a[1]

if var1 <= var2:
    print(var1)
else:
    print(var2)


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

var1 = 0
var2 = 0

for i in range(a[1]):
    var1 = var1 * 10 + a[0]

for i in range(a[0]):
    var2 = var2 * 10 + a[1]

if a[0] <= a[1]:
    print(var1)
else:
    print(var2)


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

x,y=map(int,input().split())
if x<y:
  z=0
  for i in range(0,y):
    z+=10**i*x
  print(z)
else:
  z=0
  for i in range(0,x):
    z+=10**i*y
  print(z)

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


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


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

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

print(aa if a>b else bb)

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

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

print(bb if a>b else aa)

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

list_a = [0]*int(b)
list_b = [0]*int(a)

for i in range(0,int(b)):
    list_a[i] = int(a)*10**i

for i in range(0,int(a)):
    list_b[i] = int(b)*10**i
    
a_r = sum(list_a) 
b_r =sum(list_b)

if(a<b):
    print(a_r)
elif(a>b):
    print(b_r)
else:
    print(a_r)

a = input()
b = input()

list_a = [0]*int(b)
list_b = [0]*int(a)

for i in range(0,int(b)):
    list_a[i] = int(a)*10**i

for i in range(0,int(a)):
    list_b[i] = int(b)*10**i
    
a_r = sum(list_a) 
b_r =sum(list_b)

if(int(a_r)<int(b_r)):
    print(str(a_r))
elif(int(a_r)>int(b_r)):
    print(str(b_r))
else:
    print(str(a_r))


a = input()
b = input()

list_a = [0]*int(b)
list_b = [0]*int(a)

for i in range(0,int(b)):
    list_a[i] = int(a)*10**i

for i in range(0,int(a)):
    list_b[i] = int(b)*10**i
    
a_r = sum(list_a) 
b_r =sum(list_b)

if(a<b):
    print(str(a_r))
elif(a>b):
    print(str(b_r))
else:
    print(str(a_r))

a, b = input().split()

list_a = [0]*int(b)
list_b = [0]*int(a)

for i in range(0,int(b)):
    list_a[i] = int(a)*10**i

for i in range(0,int(a)):
    list_b[i] = int(b)*10**i
    
a_r = sum(list_a) 
b_r =sum(list_b)

if(a<b):
    print(str(a_r))
elif(a>b):
    print(str(b_r))
else:
    print(str(a_r))

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

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

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

lis = [A, B]
new_lis = sorted(lis)
print(new_lis[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 = input().split()
a = int(a)
b = int(b)
astr = ""
bstr = ""
for i in range(0,a):
	astr += str(a)

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

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

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

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

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

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



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

    print(all_a)
    print(all_b)

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

if __name__ == '__main__':
    main()


# -*- coding: utf-8 -*-



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

    # print(all_a)
    # print(all_b)

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

if __name__ == '__main__':
    main()

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

#problem-b
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 = [input() for i in range(2)]
a_array = []
for i in range(int(b)):
    a_array.append(a)
a_str = "".join(a_array)

b_array = []
for i in range(int(a)):
    b_array.append(b)
b_str = "".join(b_array)


if a_str < b_str:
    print(a_str)
elif b_str < a_str:
    print(b_str)
else:
    print(a_str)


a, b = input().split()

a_array = []
for i in range(int(b)):
    a_array.append(a)
a_str = "".join(a_array)

b_array = []
for i in range(int(a)):
    b_array.append(b)
b_str = "".join(b_array)


if a_str < b_str:
    print(a_str)
elif b_str < a_str:
    print(b_str)
else:
    print(a_str)


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

ans = ""
if(A>B):
  for i in range(A):
    ans = ans + B
else:
  for i in range(B):
    ans = ans + A
    
    
    
print(ans)


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

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


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

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

res = [False for x in range(N)]
for i in range(1,N):
  if P[i-1] > P[i] :
    res[i] = True
  
print(sum(res)+1)

N = int(input())
P = list(map(int,input().split()))

res = [False for x in range(N)]
for i in range(1,N):
  if P[i-1] >= P[i] :
    res[i] = True

print(int(sum(res)+1))

N = int(input())
P = list(map(int,input().split()))

res = [False for x in range(N)]
for i in range(1,N):
  if P[i-1] >= P[i] :
    res[i] = True
  
print(sum(res)+1)

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

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

print(min([ab,ba]))


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

int_a = int(a)
int_b = int(b)

a_List = ''
b_List = ''

for i in range(int_a):
    b_List = b_List + b

for i in range(int_b):
    a_List = a_List + a


# print('a_List : ' + a_List)
# print('b_List : ' + b_List)

a_List = int(a_List)
b_List = int(b_List)

if a_List => b_List:
    print(a_List)

else:
    print(b_List)



a, b = input().split()

int_a = int(a)
int_b = int(b)

a_List = ''
b_List = ''

for i in range(int_a):
    b_List = b_List + b

for i in range(int_b):
    a_List = a_List + a


print('a_List : ' + a_List)
print('b_List : ' + b_List)

# a_List = int(a_List)
# b_List = int(b_List)


if a_List => b_List:
    print(a_List)

else:
    print(b_List)



a, b = input().split()

int_a = int(a)
int_b = int(b)

a_List = ''
b_List = ''

for i in range(int_a):
    b_List = b_List + b

for i in range(int_b):
    a_List = a_List + a


print('a_List : ' + a_List)
print('b_List : ' + b_List)

# a_List = int(a_List)
# b_List = int(b_List)


if a_List => b_List:
    print(a_List)

else:
    print(b_List)


a, b = input().split()

int_a = int(a)
int_b = int(b)

a_List = ''
b_List = ''

for i in range(int_a):
    b_List = b_List + b

for i in range(int_b):
    a_List = a_List + a


# print('a_List : ' + a_List)
# print('b_List : ' + b_List)

a_List = int(a_List)
b_List = int(b_List)

if a_List >= b_List:
    print(a_List)

else:
    print(b_List)

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

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

a,b=input().split()
A=int(a)
B=int(b)
aa=a
bb=b
for i in range(B-1):
    aa+=a
for j in range(A-1):
    bb+=b
if aa >= bb:
    print(bb)
else:
    print(aa)

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 > M:
  
    str = str(M)
    print(str*N)

else:
    str = str(N)
    print(str*M)




N,M = input().split(" ")
if N > M:
  str = str(M)
  print(str*N)
else:
  str = str(N)
  print(str*M)

N,M = input().split(" ")
if N > M:
  str = M
  print(str*int(N))
else:
  str = N
  print(str*int(M))

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

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

Verdicts: Wrong Answer

Accepted