Problem:
 Score : 200 points    Problem Statement Given are 1 -digit positive integers a and b . Consider these two strings: the concatenation of b copies of the digit a , and the concatenation of a copies of the digit b . Which of these is lexicographically smaller?      Constraints  1 \leq a \leq 9  1 \leq b \leq 9  a and b are integers.         Input Input is given from Standard Input in the following format:  a  b       Output Print the lexicographically smaller of the two strings. (If the two strings are equal, print one of them.)        Sample Input 1 4 3      Sample Output 1 3333  We have two strings 444 and 3333 . Between them, 3333 is the lexicographically smaller.       Sample Input 2 7 7      Sample Output 2 7777777

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

Solution (Python):
a, b = map(int, input().split())

a_b = str(a) * b
b_a = str(b) * a

if int(a_b[0]) >= int(b_a[0]):
    print(b_a)
else:
    print(a_b)

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

Solution (Python):
a, b = map(int, input().split())

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

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

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

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

if a <= b:
  for i in range(b):
    ans += str(a)
elif b < a:
  for i in range(a):
    ans += str(b)

print(ans)

Solution (Python):
a, b = map(int, input().split())

if a <= b:
    ans = a
    for i in range(b-1):
        ans = ans * 10 + a
else:   
    ans = b     
    for i in range(a-1):
        ans = ans * 10 + b

print(ans)

Solution (Python):
def answer(a: int, b: int) -> str:
    return min(str(a) * b, str(b) * a)


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


if __name__ == '__main__':
    main()

Solution (Python):
a, b = map(int, input().split())

print((f"{a}" * b, f"{b}" * a)[b <= a])

Solution (Python):
a, b = map(int, input().split())

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

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

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

Solution (Python):

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

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

Solution (Python):
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)

Solution (Python):
a,b = input().split()
a,b = a*int(b),b*int(a)
print(sorted([a,b])[0])

Solution (Python):
a,b = map(int,input().split())

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

Solution (Python):
from sys import setrecursionlimit, exit
setrecursionlimit(1000000000)

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

main()

Solution (Python):
import numpy as np

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

A=(''.join([str(a)]*b))
B=(''.join([str(b)]*a))

print(min(A,B))

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

Solution (Python):
a,b = map(int,input().split())
word = ""
for i in range(max(a,b)):
    word += str(min(a,b))
print(word)

Solution (Python):
a,b = map(int,input().split())

words = []
a_word = ""
b_word = ""

for i in range(a):
    b_word += str(b)
for i in range(b):
    a_word += str(a)
words.append(a_word)
words.append(b_word)
words.sort()

print(words[0])

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

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

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

Solution (Python):
a, b = map(str,input().split())
A = a*int(b)
B = b*int(a)
x = [A , B]
x.sort()
print(x[0])

Solution (Python):
a, b = map(str, input().split())

list = []
def Repetition(x:str, y:str):
    list.append(x * int(y))
    return

Repetition(a, b)
Repetition(b, a)


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

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

Solution (Python):
a, b = map(int, input().split())

a1 = a * str(b)
a2 = b * str(a)
print(min(a1, a2))

Solution (Python):
a, b = map(int, input().split())

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

Solution (Python):
ls = list(map(int,input().split()))
print(str(min(ls))*max(ls))

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

Solution (Python):
a,b=map(int,input().split())

def ans152(a:int, b:int):
    listab=[str(a)*b,str(b)*a]
    listab.sort()
    return int(listab[0])

print(ans152(a,b))

Solution (Python):

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

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


if __name__ == '__main__':
    main()

Solution (Python):
a, b = map(int, input().split())

ans = 0
if a >= b:
  for i in range(a):
    ans += b * 10**i
else:
  for i in range(b):
    ans += a * 10**i
print(ans)

Solution (Python):
a,b = input().split()

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

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

Solution (Python):
a,b=map(int,input().split())

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

Solution (Python):
a,b = map(int,input().split())
c = str(a)*b
d = str(b)*a
print(min(c,d))

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

print(str)

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

Solution (Python):

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

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

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

Solution (Python):
f = list(map(int, input().split()))
print(str(min(f)) * max(f))

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

print(A if A<=B else B)

Solution (Python):
a,b = map(int,input().split())

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

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

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

Solution (Python):
a, b = map(int, input().split())

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

Solution (Python):
a, b = input().split()
c = a * int(b)
d = b * int(a)
print(min(c, d))

Solution (Python):



def solve(a: int, b: int):
    n1 = str(a) * b
    n2 = str(b) * a
    if n1 < n2:
        return n1
    else:
        return n2


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


if __name__ == "__main__":
    main()

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

Solution (Python):
a, b = map(str, input().split())
ans = [a] * int(b) if int(a)<=int(b) else [b] * int(a)
print(''.join(ans))

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

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

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

print(ans)

Solution (Python):
N,M = map(int,input().split())
if N > M:
  ans = str(M)*N
else:
  ans = str(N)*M
print(ans)

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

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

Solution (Python):
a,b=map(int,input().split())
a1=f"{a}"*b
b1=f"{b}"*a
print(a1 if a1<b1 else b1)

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

Solution (Python):

def main():
    a, b = map(int, input().split(" "))
    for i in range(max(a,b)):
        print(min(a,b),end = "")
    print()
    

if __name__ == "__main__":
    main()

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

Solution (Python):

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

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

Solution (Python):
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 1
inf = float("inf")
al = "abcdefghijklmnopqrstuvwxyz"

a,b = I()

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

print(min(A,B))

Solution (Python):
[a, b] = [str(i) for i in input().split()]
A = a*int(b)
B = b*int(a)
s = [A, B]
S = sorted(s)
print(S[0])

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

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

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

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

Solution (Python):
a,b=map(int,input().split())

c=min(a,b)

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

Solution (Python):



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

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

Solution (Python):
a, b = map(int, input().split())
s1 = str(a) * b
s2 = str(b) * a
print(min(s1, s2))

Solution (Python):
a, b = (int(n) for n in input().split())
if a <= b: print(str(a) * b)
else: print(str(b) * a)

Solution (Python):

a, b = input().split()

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

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

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

Solution (Python):
a, b = map(int,input().split())

print(sorted([str(a)*b,str(b)*a])[0])

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

Solution (Python):
a, b = map(int, input().split())
c = str(a) * b
d = str(b) * a
print(sorted([c,d])[0])

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

Solution (Python):
a,b = input().split()

ans = ""

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

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

Solution (Python):
ri = lambda S: [int(v) for v in S.split()]
def rii(): return ri(input())
 
a, b = rii()

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

Solution (Python):
a, b = map(int, input().split())

ans = 0
if a >= b:
    for i in range(a):
        ans += b*(10**i)
else:
    for i in range(b):
        ans += a*(10**i)
print(ans)

Solution (Python):
a,b = input().split()
t = a*int(b)
q = b*int(a)

if t < q:
    print(t)
else:
    print(q)

Solution (Python):
a,b = map(int, input().split())
S = 0
for i in range(max(a,b)):
  S +=min(a,b)*(10**i)
print(S)

Solution (Python):
a,b=input().split()
c=""
i=0
if int(a)>=int(b):
  while i<int(a):
    c=c+b
    i=i+1
  print(c)
else:
  while i<int(b):
    c=c+a
    i=i+1
  print(c)

Solution (Python):
l=list(map(int, input().split()))
l.sort()
print(str(l[0])*l[1])

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

Solution (Python):
a_str, b_str = input().split()
a = int(a_str)
b = int(b_str)

A = a_str*b
B = b_str*a
 
print(min(A, B))

Solution (Python):
(a,b) = map(int,input().split())
if a < b:
    l = [str(a)]*b
    print("".join(l))
    

else:
    l = [str(b)]*a
    print("".join(l))

Solution (Python):
r=input().split()
a=int(r[0])
b=int(r[1])
if a>=b:
    ans=""
    for i in range(a):
        ans+=str(b)
    print(int(ans))
else:
    ans=""
    for i in range(b):
        ans+=str(a)
    print(int(ans))

Solution (Python):


n,m=input().split()
a=n*int(m)
b=m*int(n)
nlist=[a,b]
nlist.sort()
print(nlist[0])

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

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

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    a, b = map(int, readline().split())

    print(str(min(a, b)) * max(a, b))


if __name__ == '__main__':
    main()

Solution (Python):
a, b = input().split()

x = a
y = b

if int(a) >= int(b):
  for i in range(int(a)-1):
    y += b
  print(int(y))

else:
  for i in range(int(b)-1):
    x += a
  print(int(x))

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

Solution (Python):
A, B = map(str, input().split())
A_ans=''
B_ans=''

if min(A,B) == A:
    for a in range(int(B)):
        A_ans += A
    print(A_ans)
else:
    for b in range(int(A)):
        B_ans += B
    print(B_ans)

Solution (Python):
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)

Solution (Python):
a, b = input().split()
na = int(a)
nb = int(b)

sa = a * nb
sb = b * na

print(sa if sa < sb else sb)

Solution (Python):
a, b = map(int, input().split())

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

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

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

Solution (Python):
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)

Solution (Python):
a,b = sorted(input().split())

print(a*int(b))

Solution (Python):
  

a, b = input().split()
aaa = ""
bbb = ""
for i in range(int(b)):
    aaa += a

for i in range(int(a)):
    bbb += b

if aaa > bbb:
    print(bbb)
else:
    print(aaa)

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

Solution (Python):
a,b = map(int,input().split())

if a <= b:
	for i in range(b):
		print(a,end = "")
else:
	for i in range(a):
		print(b,end = "")

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

Solution (Python):
a,b = map(int,input().split())
ans = ""
k = min(a,b)
l = max(a,b)
for i in range(l):
  ans += str(k)
print(ans)

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

Solution (Python):
a, b = input().split()

print(sorted([a*int(b), b*int(a)])[0])

Solution (Python):
def main():
    a, b = input().split()

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

    print(ans)


if __name__ == "__main__":
    main()

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

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

Solution (Python):
a = list(map(int,input().split()))
b = sorted(a)
x = b[0]
y = b[1]
for i in range(y):
  print(x, end = '')
print()

Solution (Python):
a, b = map(int, input().split())

if a > b:
  for i in range(a):
    print(b,end="")
else:
  for i in range(b):
    print(a,end="")

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

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

Solution (Python):
a, b = map(int, input().split())

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

Solution (Python):
a=sorted(input().split())
print(a[0]*int(a[1]))

Solution (Python):

from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


def ceil(a, b):
    return (a + b - 1) // b


def sum_of_arithmetic_progression(s, d, n):
    return n * (2 * s + (n - 1) * d) // 2


def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)


def lcm(a, b):
    g = gcd(a, b)
    return a / g * b


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

def main():
    solve()


if __name__ == '__main__':
    main()

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

Solution (Python):
A, B = list(map(int, input().split()))
print(str(min(A, B))*max(A,B))

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

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

Solution (Python):
N,M = map(int,input().split())
print((str(N)*M,str(M)*N)[N > M])

Solution (Python):
a, b = list(input().rstrip().split())
ar = a * int(b)
br = b * int(a)
r = ar if ar < br else br
print(r)

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

Solution (Python):
A, B = map(int, input().split())
x = str(min(A, B))
y = max(A, B)
print(x * y)

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

Solution (Python):
a, b = input().split()
c = a
a = a*int(b)

b = b*int(c)


for i in range(len(a)):
  if a[i]<b[i]:
    print(a)
    break
  elif a==b:
    print(a)
    break
  else:
    print(b)
    break

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

Solution (Python):
a, b = map(int, input().split())

for i in range(max(a, b)):
    print(str(min(a, b)), end="")

Solution (Python):
a, b = map(int, input().split())

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

else:
    print(str(b)*a)

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

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

print(ans)

Solution (Python):
a,b=input().split()
X=a*int(b)
Y=b*int(a)
print(min(X,Y))

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

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

Solution (Python):
a,b = map(int,input().split())
minnum = min(a,b)
maxnum = max(a,b)

print(str(minnum)*maxnum)

Solution (Python):
a,b = map(str, input().split())
w = [a*int(b), b*int(a)]
w.sort()
print(w[0])

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

Solution (Python):
a,b = input().split()
ans = sorted( [a*int(b),b*int(a)] )[0]
print(ans)

Solution (Python):
import sys, bisect, math, itertools, string, queue, copy








def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

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

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

Solution (Python):
import sys

a, b = map(int, next(sys.stdin.buffer).split())
if a > b:
    a, b = b, a
print(str(a) * b)

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

Solution (Python):
a, b = map(int,input().split())
c = str(a) * b
d = str(b) * a
L = []
L += c,d
L = sorted(L) 
print(L[0])

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

Solution (Python):
a,b = map(int,input().split())

v=0
for i in range(max(a,b)):
    v = v*10+min(a,b)    

print( v )

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

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

if A < B:
    print(str(A) * B)
else:
    print(str(B) * A)

Solution (Python):
li = input().split()
li.sort()
print(li[0]*int(li[1]))

Solution (Python):
def main():

    a, b = map(int, input().split())
    s = str(a) * b
    t = str(b) * a
    if s < t:
        return s
    return t


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

Solution (Python):
a, b = map(str, input().split())

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

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

Solution (Python):
score = list(map(int,input().split()))
score.sort()
word = str(score[0])*score[1]
print(word)

Solution (Python):
a, b = sorted(map(int, input().split()))
c = str(a)
print(c*b)

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

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

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

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

Solution (Python):
import sys, bisect, math, itertools, string, queue, copy
import numpy as np
import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush
from fractions import gcd
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

a,b = inpm()

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

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

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,numpy,string
import sys
sys.setrecursionlimit(10**7)

def S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())

def main():
    a,b = LI()
    a_b = str(a)*b
    b_a = str(b)*a
    print(sorted([a_b,b_a])[0])

main()

Solution (Python):
a,b=map(int, input().split())

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

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

Solution (Python):
a,b=map(int,input().split())

s=[''.join([str(a)]*b),''.join([str(b)]*a)]

print(sorted(s)[0])

Solution (Python):
a, b = map(int, input().split())
s1 = str(a)*b
s2 = str(b)*a
print(min(s1, s2))

Solution (Python):
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)

Solution (Python):
a,b = map(int,input().split())

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

print(min(A,B))

Solution (Python):
a,b = map(int,input().split())

x = str(a) * b
y = str(b) * a
print(min(sorted([x,y])))

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

Solution (Python):
a,b=map(int,input().split())
A=[str(a)*b]
B=[str(b)*a]
if a>b:
    print(int(''.join(B)))
if a<b:
    print(int(''.join(A)))
if a==b:
    print(int(''.join(A)))

Solution (Python):
a,b=input().split()
x=''
y=''
for i in range(int(b)):
  x+=a
for i in range(int(a)):
  y+=b

l=[x,y]

l.sort()

print(l[0])

Solution (Python):


from typing import *
import collections
import functools
import itertools
import math
import sys

INF = float('inf')


def solve(a: int, b: int):
    return str(sorted([a, b])[0]) * sorted([a, b])[1]


def main():

    sys.setrecursionlimit(10 ** 6)

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    a = int(next(tokens))  
    b = int(next(tokens))  
    print(f'{solve(a, b)}')


if __name__ == '__main__':
    main()

Solution (Python):
a,b=(input().split())
ai=int(a)
bi=int(b)
c1=(b*ai)
c2=(a*bi)  
ast=str(c1)
bst=str(c2)
if ast<bst:
  print(ast)
else:
  print(bst)

Solution (Python):
a,b = map(str,input().split())

As = a * int(b)

Bs = b * int(a)

if As<Bs:
  print(As)
else:
  print(Bs)

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

Solution (Python):
a, b = [int(i) for i in input().split()]
aa = ''.join([str(a) for v in range(b)])
bb = ''.join([str(b) for v in range(a)])
print(aa if aa < bb else bb)

Solution (Python):
import os, sys, re, math

(a, b) = [int(n) for n in input().split()]

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

Solution (Python):
a, b = [int(s) for s in input().split()]
print(sorted([str(a)*b, str(b)*a])[0])

Solution (Python):
a,b = input().split()
aaa = a * int(b)
bbb = b * int(a)
print(min(aaa, bbb))

Solution (Python):
a, b = map(int, input().split())

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

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

Solution (Python):

a, b = map(int, input().split())
a, b = min(a, b), max(a, b)
ans = ''.join([str(a) for e in range(b)])
print(ans)

Solution (Python):
a, b = map(int, input().split())

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

Solution (Python):
a, b = map(int, input().split())
alpha = str(b)
beta = str(a)
if a >= b:
  for k in range(a - 1):
    alpha = alpha + str(b)
  print(int(alpha))
else:
  for k in range(b - 1):
    beta = beta + str(a)
  print(beta)

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

Solution (Python):
def main():
    a, b = map(int, input().split())
    l = [str(a) * b, str(b) * a]
    ans = sorted(l)[0]
    print(ans)

if __name__ == '__main__':
    main()

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

Solution (Python):
a, b = map(int, input().split())

A = str(a) * b
B = str(b) * a
print(A) if A < B else print(B)

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

Solution (Python):
a, b = input().split()

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

lis = [A, B]

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

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

Solution (Python):
a,b = input().split()

x = int(a) * b
y = int(b) * a
l = []
l.append(x)
l.append(y)
l = sorted(l)

print(min(l))

Solution (Python):
n, m= map(int, input().split(" "))

print(min(str(n)*m, str(m)*n))

Solution (Python):
def resolve():
    a, b = list(map(int, input().split()))
    print(str(a)*b if a < b else str(b)*a)

if '__main__' == __name__:
    resolve()

Solution (Python):
a, b = input().split(" ")
if int(a) > int(b):
  print("".join([b] * int(a)))
else:
  print("".join([a] * int(b)))

Solution (Python):
S ,T = map(int, input().split())
print(str(S)*T if S<=T else str(T)*S )

Solution (Python):
MM = input().split()
a = int(MM[0])
b = int(MM[1])
list1 = [str(a)*b,str(b)*a]
list1.sort()
print(list1[0])

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

Solution (Python):
a, b = list(map(int, input().split()))
arr = [str(a) * b, str(b) * a]
arr.sort()
print(arr[0])

Solution (Python):
a,b = map(int,input().split())
num_a = ''
num_b = ''
lst = []
for i in range(b):
    num_a += str(a)
for i in range(a):
    num_b += str(b)
lst.append(num_a)
lst.append(num_b)
lst.sort()
print(lst[0])

Solution (Python):
a, b = map(int, input().split())

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

Solution (Python):
a,b = input().split()
c = [a*int(b), b*int(a)]
print(sorted(c)[0])

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

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

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

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

Solution (Python):
a,b=map(str,input().split())
ans1=a*int(b)
ans2=b*int(a)
l=[ans1,ans2]
l.sort()
print(l[0])

Solution (Python):
def solve():
    a,b = [int(i) for i in input().split()]
    smaller = min(a, b)
    bigger = max(a, b)
    print(''.join([str(smaller)]*bigger))

if __name__ == "__main__":
    solve()

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

Solution (Python):
a,b=input().split()

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

print(a_list[0])

Solution (Python):
a, b = map(int,input().split())

if a < b:
    a, b = b, a

b = str(b)

print(b*a)

Solution (Python):
a, b = input().split()

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