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):
import sys
 
stdin = sys.stdin
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()
nas = lambda: stdin.readline().split()

a, b = na()

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

print()

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

if a != b:
    for i in range(max(a,b)):
        print(min(a, b),end='')
else:
    for i in range(a):
        print(b,end='')

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

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

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

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

Solution (Python):

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

a_num = str(a) * b
b_num = str(b) * a

print(min(str(a_num), str(b_num)))

Solution (Python):
a,b = (int(i) for i in 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())

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

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

s1 = str(a) * b
s2 = str(b) * a

print(s1 if s1 < s2 else s2)

Solution (Python):

import re
import math


mod=int(10**9+7)


a,b=map(int,input().split())
ans=""
min_=min(a,b)
max_=max(a,b)
for i in range(max_):
    ans+=str(min_)
print(ans)

Solution (Python):
import math
import calendar
import fractions
import itertools

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

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

if a_s < b_s:
    print(a_s)
else:
    print(b_s)

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

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='')
print()

Solution (Python):
import sys
def input():
    return sys.stdin.readline()[:-1]

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

Solution (Python):
a,b = map(str, input().split())
an = ""
for i in range(int(b)):
    an+=a
bn = ""
for i in range(int(a)):
    bn += b
ans = []
ans.append(an)
ans.append(bn)
ans.sort()
print(ans[0])

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

Solution (Python):
import sys

a, b = sys.stdin.readline().split()

def main():
    s = a * int(b)
    t = b * int(a)
    return s if s < t else t

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

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

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

al = [a for i in range(b)]
bl = [b for i in range(a)]

li = []
li.append("".join(map(str, al)))
li.append("".join(map(str, bl)))
li.sort()
print(li[0])

Solution (Python):
a,b=map(int,input().split())
a_str=""
b_str=""
for s in range(a):
    a_str+=str(b)
for s in range(b):
    b_str+=str(a)

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

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

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

if int(A) >= int(B):
  print(b)
else:
  print(a)

Solution (Python):
a,b=map(int,input().split())
sa=str(a)*b
bs=str(b)*a
print((sa,bs)[bs<sa])

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(int,input().split())
sa=str(a)
aa=sa*b
sb=str(b)
bb=sb*a
print(min(aa,bb))

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

Solution (Python):

import sys


def solve(a: int, b: int):
    if a<b:
        print(str(a)*b)
    else:
        print(str(b)*a)
    return



def main():
    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))  
    solve(a, b)

if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

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

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

A = a * int(b)
B = b * int(a)
W = [A, B]
W = sorted(W)
print(W[0])

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

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

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

Solution (Python):
n,m = map(int,input().split())
s = ""
if n>=m:
  s = str(m)*n
  print(s)
else:
  s = str(n)*m
  print(s)

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

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

Solution (Python):

import sys
input = sys.stdin.buffer.readline


from collections import defaultdict


def getlist():
	return list(map(int, input().split()))


def main():
	a, b = getlist()
	A = str(a) * b
	B = str(b) * a
	ans = sorted([A, B])
	print(ans[0])


if __name__ == '__main__':
	main()

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

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

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






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

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
 
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
 
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

a, b  = MAP()
a_a = str(a)
b_b = str(b)
c = [a_a] * b
d = [b_b] * a
c = "".join(c)
d = "".join(d)
print(min(c, d))

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

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

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

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

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

Solution (Python):
a, b = input().split()
ansb = []
for i in range(int(a)):
    ansb.append(b)
ansa = []
for i in range(int(b)):
    ansa.append(a)
ansa = "".join(ansa)
ansb = "".join(ansb)
ans = [ansa, ansb]
ans.sort()
print(ans[0])

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

Solution (Python):
a,b = input().split()
if a < b:
    for i in range(int(b)):
        print(a,end="")
else:
    for i in range(int(a)):
        print(b,end="")

Solution (Python):
import sys
def input():
    return sys.stdin.readline()[:-1]
a,b=map(int,input().split())
s=""
t=""
if a<b:
    for i in range(b):
        t+=str(a)
    print(t)
else:
    for i in range(a):
        s+=str(b)
    print(s)

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

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

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

Solution (Python):
a,b = map(int,input().split())
x = min(a,b)
y = max(a,b)
ans = []
for i in range(y):
    ans.append(str(x))
print(''.join(ans))

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

Solution (Python):
import sys
sys.setrecursionlimit(1000000000)
import math
from fractions import gcd
from itertools import count, permutations
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok


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

main()

Solution (Python):
a, b = map(int, input().split())
x = min([a, b])
y = max([a, b])

print(str(x)*y)

Solution (Python):
import sys
input = sys.stdin.readline
a, b = [int(x) for x in input().split()]
A = str(a) * b
B = str(b) * a
C = [A, B]
C.sort()
print(C[0])

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

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

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

Solution (Python):


import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
read = sys.stdin.read





a,b = readline().split()

p = a*int(b)
q = b*int(a)

print(min(p,q))

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

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

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

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

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

Solution (Python):
a,b = list(map(int, input().split()))
tmp = str(a)*b
tmp2 = str(b)*a

print(min(tmp,tmp2))

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

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

Solution (Python):






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

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

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

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

Solution (Python):
a,b=map(int,input().split())
ans=[]
for i in range(max(a,b)):
    ans.append(min(a,b))
print(*ans,sep="")

Solution (Python):


a, b = list(map(int, input().split()))
ans = list(sorted([str(a) * b, str(b) * a]))[0]
print(ans)

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 b > a:
    print(''.join([str(a) for _ in range(b)]))
else:
    print(''.join([str(b) for _ in range(a)]))

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

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

Solution (Python):
a,b = [int(x) for x in input().split()]
c,d = "",""
for i in range(a):
	c+=str(b)
for i in range(b):
	d+=str(a)
if c<d:
	print(c)
else:
	print(d)

Solution (Python):
a,b = (int(i) for i in input().split())

ans = ""
roop = max(a,b)
min_num_str = str(min(a,b))

for i in range(roop):
  ans += min_num_str

print(ans)

Solution (Python):


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

temp=[]
temp.append([str(a)]*b)
temp.append([str(b)]*a)
temp.sort()

print("".join(temp[0]))

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):
import sys
import math
stdin = sys.stdin
mod = 10**9 + 7

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
sa = lambda h: [list(map(int, stdin.readline().split())) for i in range(h)]


a, b = na()
c = max(a, b)
d = min(a, b)
print(str(d)*c)

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

Solution (Python):
nm=input().split(" ")
N=int(nm[0])
M=int(nm[1])
if N<M:
  print(str(N)*M)
else:
  print(str(M)*N)

Solution (Python):
a,b=map(int,input().split())
A=B=''
for _ in range(a):
    A+=str(b)
for _ in range(b):
    B+=str(a)

print(A if A<B else B)

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline

    a, b = input().split()
    A = a * int(b)
    B = b * int(a)
    C = [A, B]
    C.sort()
    print(C[0])


if __name__ == '__main__':
    main()

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

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

Solution (Python):
import sys

sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return list(map(int, sys.stdin.readline().split()))
def II(): return int(sys.stdin.readline())
def LS(): return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]

def main():
    a, b = LI()
    if a > b:
        print(str(b) * a)
    else:
        print(str(a) * b)

if __name__ == '__main__':
    main()

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

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

Solution (Python):


a, b = input().split()

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

if a_ < b_:
    print(a_)
else:
    print(b_)

Solution (Python):
k, m = input().split()
km = k * int(m)
mk = m * int(k)
if km < mk:
  print(km)
else:
  print(mk)

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

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

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

Solution (Python):

a,b = input().split()

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

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

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

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

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

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

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

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

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

num1 = ''
num2 = ''
for i in range(b):
  num1 += str(a)
for i in range(a):
  num2 += str(b)

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

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

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

x = "".join([str(a)] * b)
y = "".join([str(b)] * a)
if x < y:
    print(x)
else:
    print(y)

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

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

m = min([a, b])
n = max([a, b])

print(str(m) * n)

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

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

s = ""
for _ in range(b):
    s += str(a)
t = ""
for _ in range(a):
    t += str(b)

print(min(s, t))

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 = input().split()
aa = a*int(b)
bb = b*int(a)
print(sorted([aa,bb])[0])

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

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

Solution (Python):
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time


def I(): return int(input())


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


def S(): return input()


def MS(): return map(str, input().split())


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


def input(): return sys.stdin.readline().rstrip()


def show(*inp, end='\n'):
    if show_flg:
        print(*inp, end=end)


YN = ['No', 'Yes']
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

show_flg = False



def main():
    a, b = MS()
    A = a * int(b)
    B = b * int(a)

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


if __name__ == '__main__':
    main()

Solution (Python):





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

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

    return ans


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

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

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

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

A = str(a)*b
B = str(b)*a
A_B = [A, B]
A_B.sort()
print(A_B[0])

Solution (Python):


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

x=""

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

y=""

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

print(min(x,y))

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

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

Solution (Python):
import sys

def get_ints(): return map(int, sys.stdin.readline().strip().split())
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))

a,b = get_ints()
A = str(b)*a
B = str(a)*b
print(min(A,B))

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

print(sorted([A*int(B), B*int(A)])[0])

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

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

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

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

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

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 = str(a)*b
d = str(b)*a
print(sorted([c, d])[0])

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

a_to_b = str(a) * b
b_to_a = str(b) * a

if a_to_b > b_to_a:
    print(b_to_a)
else:
    print(a_to_b)

Solution (Python):
from bisect import bisect_right, bisect_left
from itertools import groupby, permutations, combinations
from fractions import gcd
import numpy as np
from sys import stdin, stderr


def lcm(x, y):
    return (x * y) // gcd(x, y)


def main():
    a, b = [int(x) for x in input().split()]
    if a > b:
        a, b = b, a
    ret = str(a) * b
    return ret


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

Solution (Python):
n,m = map(str, input().split())
n1 = n*int(m)
m1 = m*int(n)
print(min(n1,m1))

Solution (Python):
import sys
import copy
import math
import numpy as np
a,b=map(str,input().split())
res = []
res.append(a*int(b))
res.append(b*int(a))
print(sorted(res)[0])

Solution (Python):

import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline

a, b = [item for item in input().split()]
pata = a * int(b)
patb = b * int(a)

if pata < patb:
    print(pata)
else:
    print(patb)

Solution (Python):
H, W = map(int, input().split())

if H < W:
  print(str(H)*W)
else:
  print(str(W)*H)

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

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

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

print(ans)

Solution (Python):
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush
from fractions import gcd
from copy import deepcopy
import math
import queue


Mod = 1000000007
import sys

sys.setrecursionlimit(100000) 
  
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

def factorial(i):
    if i == 1:
        return 1
    else:
        return i*factorial(i-1)
 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[py] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)




def main(): 
    a,b = input().split()
    p = [a*int(b),b*int(a)]
    p.sort()
    print(p[0])
if __name__ == "__main__":
    main()

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

if a > b:
    for _ in range(a):
        print (b, end = '')
else:
    for _ in range(b):
        print (a, end = '')

print ()

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

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

Solution (Python):
import sys
input = sys.stdin.readline
a,b = input().split()
lia = [a] * int(b)
lib = [b] * int(a)
A = ''.join(lia)
B = ''.join(lib)
if A >= B :
    print(B)
else :
    print(A)

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

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

Solution (Python):






import math
import statistics
import numpy as np
import queue

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 = '')
print('')

Solution (Python):


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

s1 = str(a)*b
s2 = str(b)*a


lis = [s1, s2]
lis = sorted(lis)

print(lis[0])

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

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

Solution (Python):


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

Solution (Python):


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

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

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

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

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

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

Solution (Python):

a, b = map(int, input().split())
min_num = min(a, b)
max_num = max(a, b)

print(str(min_num)*max_num)

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

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

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

print('')

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

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

astr = str(a) * b
bstr = str(b) * a

if astr < bstr:
    print(astr)
else:
    print(bstr)

Solution (Python):
N,M = input().split()
x = M * (int(N))
y = N * int(M)
print(min(x,y))

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

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

tiisai = min(a, b)
ookii = max(a, b)

print(str(tiisai)*ookii)

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

c = min(a,b)

ans = str(c) * max(a,b)

print(ans)

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)

print(min(A, B))

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

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

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1

def read_int():
    return int(input())


def read_int_n():
    return list(map(int, input().split()))


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(A, B):
    if A > B:
        return str(B) * A
    else:
        return str(A) *B


def main():
    A, B = read_int_n()
    print(slv(A, B))


if __name__ == '__main__':
    main()

Solution (Python):


import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

a, b = input().split()

x = a * int(b)
y = b * int(a)
if x <= y:
    print(x)
else:
    print(y)

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

Solution (Python):
[a,b] = list(map(int,input().split()))
M = min(a,b)
N = max(a,b)
output = ""
for i in range(N):
    output += str(M)
print(output)

Solution (Python):
import math
import itertools
import fractions
import heapq
import collections
import bisect
import sys

sys.setrecursionlimit(10**9)
mod = 998244353
inf = 10**20

def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()

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

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

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

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

print(min((a * bi, b * ai)))

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

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