TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: Silver Fox is fighting with N monsters.  The monsters are standing in a row, and we can assume them to be standing on a number line. The i-th monster, standing at the coordinate X_i, has the _health_ of H_i.  Silver Fox can use bombs to attack the monsters. Using a bomb at the coordinate x decreases the healths of all monsters between the coordinates x-D and x+D (inclusive) by A. There is no way other than bombs to decrease the monster's health.  Silver Fox wins when all the monsters' healths become 0 or below.  Find the minimum number of bombs needed to win.

Submission attempts (in order):
n, d, a = map(int, input().split())
XH = [tuple(map(input().split())) for i in range(n)]
XH.sort()
X = [x for x, h in XH]
H = [h for x, h in XH]
X.append(10**10)
H.append(0)
j = 0
S = [0]*(n+1)
ans = 0
for i in range(n):
    H[i] = max(0, H[i]-S[i])
    c = -(-H[i]//a)
    while X[j] <= X[i] + 2*d:
        j += 1
    S[i+1] += S[i] + a*c
    S[j] -= a*c
    ans += c
print(ans)


n, d, a = map(int, input().split())
XH = []
for i in range(n):
    x, h = map(int, input().split())
    XH.append((x, h))
XH.sort()
X = [xh[0] for xh in XH]
H = [xh[1] for xh in XH]
X.append(10**10)
H.append(0)
j, c, s = 0, 0, 0
for i in range(n):
    H[i] -= s
    c += -(-H[i]//a)
    s = a*(-(-H[i]//a))
    while X[j] <= X[i]+2*d:
        j += 1
    H[j] += s
print(c)


n, d, a = map(int, input().split())
XH = [tuple(map(int, input().split())) for i in range(n)]
XH.sort()
X = [x for x, h in XH]
H = [h for x, h in XH]
X.append(10**10)
H.append(0)
j = 0
S = [0]*(n+1)
ans = 0
for i in range(n):
    H[i] = max(0, H[i]-S[i])
    c = -(-H[i]//a)
    while X[j] <= X[i] + 2*d:
        j += 1
    S[i+1] += S[i] + a*c
    S[j] -= a*c
    ans += c
print(ans)


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

for i in range(1, a+1):
    c.append(b)

for j in range(1, b+1):
    d.append(a)

if a > b:
    print(c)
else:
    print(d)

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

a,b = map(int, input().split())
if(a==b):
  print("Yes")
else:
  print("No")

a, b = map.(int, input().split())
if(a==b):
    print("Yes")
    else:
	print("No")

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

Verdicts: Wrong Answer

Wrong Answer

Runtime Error

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

Submission attempts (in order):
a,b = input().split()
aa=''.join([int(a) for _ in range(int(b))])
bb=''.join([int(b) for _ in range(int(a))])
print(max(int(aa),int(bb)))
           

a,b = input().split()
aa=''.join([a for _ in range(int(b))])
bb=''.join([b for _ in range(int(a))])
print(max(int(aa),int(bb)))

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

if i[0]<i[1]:
    for n in range(i[1]):
        ans += i[0]*10**n
        print(ans)

else:
    for n in range(i[0]):
        ans += i[1]*10**n
        print(ans)
print(ans)

i = list(map(int, input().split()))
ans=0

if i[0]<i[1]:
    for n in range(i[1]):
        ans += i[0]*10**n

else:
    for n in range(i[0]):
        ans += i[1]*10**n

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

ans_a = 0
ans_b = 0
ans = []
for i in range(b):
    ans_a = ans_a + a*10**i

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

ans_a = str(ans_a)
ans_b = str(ans_b)

print(ans_a,ans_b)
print(type(ans_a),type(ans_b))

ans = [ans_a,ans_b]
print(sorted(ans))
answer = ans[0]
print(answer)

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

ans_a = 0
ans_b = 0
ans = []
for i in range(b):
    ans_a = ans_a + a*10**i

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

ans_a = str(ans_a)
ans_b = str(ans_b)

ans = [ans_a,ans_b]
answer = sorted(ans)
c = answer[0]
print(answer[0])

Verdicts: Wrong Answer

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

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

lis = []
res_a = a
res_b = b

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

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

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

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

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())
aStr = str()
bStr = str()

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

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

lst = list()
lst.append(aStr)
lst.append(bStr)
lst.sort()
print(lst[0])


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

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

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

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

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

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


Verdicts: Runtime Error

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

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

if a<b :
    for i in range(b) :
        print(a)
else :
    for i in range(a) :
        print(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 = (int(x) for x in input().split())
a = str(a)*b
b = str(b)*a
lis = [a, b]
new_lis = soted(lis)
print(new_lis[1])

a, b = (int(x) for x in input().split())
a1 = str(a)*b
b1 = str(b)*a
lis = [a1, b1]
new_lis = sorted(lis)
print(new_lis[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):
def main():
    a, b = input().split()
    A = a*int(a)
    B = b*int(b)
    ans = sorted([A, B])
    print(ans[0])


if __name__ == "__main__":
    main()

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


if __name__ == "__main__":
    main()

Verdicts: Wrong Answer

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

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

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

Verdicts: Wrong Answer

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

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

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

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

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

a,b=map(int,input().split())
print(min(str(a)*b,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 = [i for i in input().split()]
print(max(int(a * int(b)), int(b * int(a)))

a, b = [i for i in input().split()]
print(max(int(a * int(b)), int(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(str, input().split()))
a.sort()
print(a[0])

a = list(map(str, input().split()))
a[0],a[1] = a[0]*int(a[1]),a[1]*int(a[0])
a.sort()
print(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):
# B
a, b = map(int, input().split())

a2 = int(str(a)*b)
b2 = int(str(b)*a)

if a2<b2:
  print(a2)
else:
  print(b2)

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

a2 = str(a)*b
b2 = str(b)*a

if a<b:
  print(a2)
else:
  print(b2)

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

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

x=''

for i in range(a):
  x += str(b)
  
y=''

for i in range(b):
  y += str(a)
  
print(min(x,y))
 


a,b = list(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,open(0));print(str(min(a,b))*max(a,b))


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

Verdicts: Runtime Error

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

Submission attempts (in order):
n = list(map(int,input().split()))
a = n[0]
b = n[1]
tmp = 0
if a < b:
    for i in range (a):
        tmp += b * (10 ** i)
    print (tmp)
else:
    for i in range (b):
        tmp += a * (10 ** i)
    print (tmp)

n,m=map(int,input().split())
mn = min(m,n)
mx = max(m,n)
print(str(mn)*mx)

Verdicts: Wrong Answer

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

Submission attempts (in order):
a,b=map(int,input().split())
A=str(a)*b
B=str(b)*a
l=[A,B]
print(l)
l.sort()
print(l)

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

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())
ans = 0
if a>=b:
  for i in range(a):
    ans += b*(10**a)
  print(ans)
else:
  for j in range(b):
    ans += a*(10**b)
  print(ans)
  


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

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

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

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

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

ans1 = ""
ans2 = ""
for i in range(b):
  ans1.append(a)

for i in range(a):
  ans2.append(b)
  
print(ans1, ans2)

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

ans1 = ""
ans2 = ""
for i in range(b):
  ans1 = ans1 + str(a)

for i in range(a):
  ans2= ans2 + str(b)
  
list = []
list.append(ans1)
list.append(ans2)

list.sort()

print(list[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())
x, y = 0, 0
for i in range(b):
    x += a * (10 ** (b - 1))
for i in range(a):
    y =+ b * (10 ** (a - 1))
if a <= b:
    print(x)
else:
    print(y)

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

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

Verdicts: Wrong Answer

Wrong Answer

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

Submission attempts (in order):
a,b=map(int,input().split())
c=0
for i in range(a):
  c+=b*(10**i)

d=0
for j in range(b):
  d+=a*(10**j)

e=min(c,d)
print(e)

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

for i in range(a):
  c+=b*(10**i)

d=0
for j in range(b):
  d+=a*(10**j)

e=c if b<a else d
print(e)


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

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


a,b=input().split()
num_a=int(a*int(b))
num_b=int(b*int(a))

if num_a>num_b:
    print(num_a)
elif num_a<num_b:
    print(num_b)
else:
    print(num_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(str,input().split())
res = ""
if a < b:
  for i in range(b):
    res += a
else:
  for i in range(a):
  res += b
print(res)

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

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 sys
ab = sys.stdin.readline().split(' ')
print(max(ab[0]*int(ab[1]), ab[1]*int(ab[0]))

ab = input().split(' ')
print(max(ab[0]*int(ab[1]), ab[1]*int(ab[0])))

ab = input().split(' ')
print(max(ab[0]*int(ab[1]), ab[1]*int(ab[0]))

ab = input().split(' ')
print(min(ab[0]*int(ab[1]), ab[1]*int(ab[0])))

Verdicts: Runtime Error

Wrong Answer

Runtime Error

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

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

ab = ""
ba = ""

for i in range(b+1):
  ab = ab + input_ab[0]

for i in range(a+1):
  ba = ba + input_ab[1]

dic = [ab, ba]
sdic = sorted(dic)

print(sdic[0])


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

ab = ""
ba = ""

for i in range(b):
  ab = ab + input_ab[0]

for i in range(a):
  ba = ba + input_ab[1]

dic = [ab, ba]
sdic = sorted(dic)

print(sdic[0])


Verdicts: Wrong Answer

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

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

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

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

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_str = 'a' * b
b_str = 'b' * a

if a < b:
    print(a_str)
elif b > a:
    print(b_str)
else:
    print(a_str)

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

a_str = str(a) * b
b_str = str(b) * a

if a < b:
    print(a_str)
elif a > b:
    print(b_str)
else:
    print(a_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=input()
A=int(a*b)
B=int(b*a)
print(min(A,B))

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

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

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()
aa = ""
bb = ""
for i in range(1, int(b)):
    aa += a
for j in range(1, int(a)):
    bb += b

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

a, b = input().split()
aa = ""
bb= ""
for i in range(1, int(b)-1):
    aa += a
for j in range(1, int(a)-1):
    bb += b

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

a = input()
b = input()
sumA = ""
sumB = ""
for i in range(int(b)):
    sumA +=""+str(a)
for i in range(int(a)):
    sumB +=""+str(b)
if(int(sumA)>int(sumB)):
    print(sumA)
elif(int(sumB)>int(sumA)):
    print(sumB)
elif(int(sumA) == int(sumB)):
    print(sumA)

a, b = input().split()
sumA = ""
sumB = ""
for i in range(int(b)):
    sumA +=""+str(a)
for i in range(int(a)):
    sumB +=""+str(b)
if(int(sumA)>int(sumB)):
    print(sumA)
elif(int(sumB)>int(sumA)):
    print(sumB)
elif(int(sumA) == int(sumB)):
    print(sumA)

Verdicts: 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())
a= min(a,b)
b= max(a,b)

print(str(a)*b)

a, b = map(int, input().split())
x= min(a,b)
y= max(a,b)

print(str(x)*y)

Verdicts: Wrong Answer

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

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

a_s = str(a)
b_s = str(b)

a_w=a_s
b_w=b_s

while a > 1:
    a_w+=a_s
    a -= 1

while b > 1:
    b_w+=b_s
    b -= 1

if(int(a_w)>=int(b_w)):
    print(int(a_w))
else:
    print(int(b_w))

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

a_s = str(a)
b_s = str(b)

a_w=a_s
b_w=b_s

while b > 1:
    a_w+=a_s
    b -= 1

while a > 1:
    b_w+=b_s
    a -= 1

test_list = [a_w, b_w] 

res = min(filter(lambda s:isinstance(s, str), test_list)) 

print(res)


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

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


Verdicts: Runtime Error

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

Submission attempts (in order):
n = min[int(i) for in in input().split()]
print(str(n)*int(n))

n = min([int(i) for i in input().split()])
print(str(n)*int(n))

n = [int(i) for i in input().split()]
print(str(min(n)) * max(n))

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


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


Verdicts: Wrong Answer

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

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

print(ans)

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


a, b = input().split()

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



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


Verdicts: Wrong Answer

Wrong Answer

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

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

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


Verdicts: Wrong Answer

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

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

print(str(np.sort(i)[0]) * np.sort(i)[1])



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

print(str(sorted(i)[0]) * sorted(i)[1])



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

ab = ''
ba = ''

for i in range(b):
    ab += str(b)

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

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

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

ab = ''
ba = ''

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

for i in range(b):
    ba += str(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):
O, K = input().split()
i = O*int(k)
u = K*int(O)
print(sorted([i,u])[0])

O,K = input().split()
I = O*int(k)
U = K*int(O)
print(sorted([I,U])[0])

O,K = input().split()
I = O*int(K)
U = K*int(O)
print(sorted([I,U])[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 = map(int,input().split())
if a<b:
  min = a
  max = b
else:
  min = b
  max = a
c =[min for i in range(max)]
l = "".join(c)
print(l)

a,b = map(int,input().split())
if a<b:
  min = a
  max = b
else:
  min = b
  max = a
c =[min for i in range(max)]
d = map(str,c)
l = "".join(d)
print(l)

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


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

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

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


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

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

if a>=b:
  print(str(b*a))
elif b>=a:
  print(str(a*b))

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

if a>=b:
  print(b*int(a))
elif b>=a:
  print(a*int(b))

Verdicts: Runtime Error

Wrong Answer

Wrong Answer

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

Submission attempts (in order):
a,b = map(int,input().split())
c = 'a'*b
d = 'b'*a
if int(c[0]) <= int(d[0]):
  print(int(c))
else:
  print(int(d))

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

Verdicts: Runtime Error

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

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

a,b = (int(x) for x in input().split())
if a>b:
	x = a
	a = b
	b = x
print("%d"%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):
s = list(map(int,input().split()))
a = s[0]
b = s[1]
c = 0
if a > b:
    for i in range(b):
        c = c + (10**i) * a
else:
    for i in range(a):
        c = c + (10**i) * b
print(c)

s = list(map(int,input().split()))
a = s[0]
b = s[1]
c = 0
if a < b:
    for i in range(b):
        c = c + (10**i) * a
else:
    for i in range(a):
        c = c + (10**i) * b
print(c)

Verdicts: Wrong Answer

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

Submission attempts (in order):
a,b=map(str,input().split())
ab:str=""
ba:str=""
for i in range(int(a)):
    ab+=b
for i in range(int(b)):
    ba+=a
#print(ab)
#print(ba)
if(int(ab)>int(ba)):
    print(int(ba))
elif(int(ab)==int(ba)):
    print(int(ab))
else:
    print(int(ab))

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

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()
l = [str(a) * int(b), str(b) * int(a)].sort()
print(l[0])

a, b = 4, 3
l = [str(a) * int(b), str(b) * int(a)]
l.sort
print(l[0])

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

Verdicts: Runtime Error

Wrong Answer

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

Submission attempts (in order):
a,b = map(int,input().split())
s = ''
if a> b:
    for i in range(len(b)):
        s = s+str(a)
else:
    for i in range(len(a)):
        s = s+str(b)
print(s)

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

    return min(a,b)

if __name__ == "__main__":

    a, b = inpu().split()

    ans = slove(a, b)
    print(ans)


def slove(a, b):

    return min(a,b)

if __name__ == "__main__":

    a, b = input().split()

    ans = slove(a, b)
    print(ans)

def make_num(a, b):
    num = ""
    for i in range(b):
        num += str(a)
    return num

def slove(a, b):

    num1 = make_num(a, b)
    num2 = make_num(b, a)
    
    return min(num1, num2)

if __name__ == "__main__":

    a, b = [int(i) for i in input().split()]
    ans = slove(a, b)
    print(ans)

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):
n, m = input().split()
nn = m*int(n)
mm = n*int(m)
print(min(int(nn), int(mm)))



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

a,b=map(int,input().split())
if a < b :
    print(aをb桁)
elif b < a :
    print(bをa桁)
else :
    print(aをb桁)

a,b=map(int,input().split())
if a < b :
    print(aをb桁)
elif b < a :
    print(bをa桁)
else :
    print(aをb桁)

a,b = input().split()
atxt = ''.join([a for _ in range(int(b))])
btxt = ''.join([b for _ in range(int(a))])
if atxt <= btxt :
    print(atxt)
else :
    print(btxt)

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

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

Verdicts: Wrong Answer

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

Submission attempts (in order):
a,b= input().split()
x=int(a*int(b))
y=int(b*int(a))
c=[x,y]
c.sort
print(c[0])



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

a,b= input().split()
x=int(a*int(b))
y=int(b*int(a))

if x>y:print(x)
else:print(y)



Verdicts: Wrong Answer

Wrong Answer

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

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

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

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

newa = str(a)*b
newb = str(b)*a

print(min([int(newa),int(newb)]))

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

newa = str(a)*b
newb = str(b)*a

list = newa,newb
list = sorted(list)
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 = map(int,input().split())
if A >= B :
  out = str(A) * B
else:
  out = str(B) * A

print(out)


A,B = map(int,input().split())
if A <= B :
  out = str(A) * B
else:
  out = str(B) * 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] = [int(s) for s in input().rstrip().split(' ')]
W = ""
if a < b:
  for i in range(b):
    W.append(str(a))
  print(W)
else:
  for i in range(a):
    W.append(str(b))
  print(W) 
  

[a,b] = [int(s) for s in input().rstrip().split(' ')]
W = ""
if a < b:
  for i in range(b):
    W += str(a)
  print(W)
else:
  for i in range(a):
    W += str(b)
  print(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):
    for i in range (0,b):
        print(a)
else:
    for i in range(0,a):
        print(b)

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

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()
c=int(a)
d=int(b)
e=(a*d)
f=(b*c)
g=e[0:1]
h=f[0:1]
if g<=h:
    print(g)
else:
    print(h)


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


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

l = a ** int(b)
r = b ** int(a)

l = int(l)
r = int(r)

if l > r:
    print(l)
else
    print(r)

a, b = input().split()

l = a * int(b)
r = b * int(a)
 
l = int(l)
r = int(r)
 
if l > r:
    print(l)
else:
    print(r)

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()))
big = 0
small =0
if a > b:
  big = a
  small = b
else:
  big = b
  small = a
  
s = ""
for i in range(b):
  s += str(small)

print(s)

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


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') for i in range(b)
else:
    print ('b') for i in range(a)
    


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


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


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

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

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

Verdicts: Runtime Error

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,S = [int(x) for x in input().split()]
a=max(N,S)
b=min(N,S)
c=0
for i in range(b): c+=a*10**i
print(c)

N,S = [int(x) for x in input().split()]
a=max(N,S)
b=min(N,S)
c=0
for i in range(min): c+=a*10**i
print(c)

N,S = [int(x) for x in input().split()]
a=max(N,S)
b=min(N,S)
c=0
for i in range(a): c+=b*10**i
print(c)

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

x = int(a * int(b))
y = int(b * int(a))

print(min(x, y))


a, b = input().split()

x = a * int(b)
y = b * int(a)

print(min(x, y))


Verdicts: Wrong Answer

Accepted