output_description: Print the lexicographically smaller of the two strings. (If the two strings
  are equal, print one of them.)
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      a b
attempt: import numpy as np
  
  a, b = map(int, input().split())
  if (a * 10**b) > (b * 10**a):
      print(
          np.ceil(
              a
              * (
                  10**b
                  + 10 ** (b - 1)
                  + 10 ** (b - 2)
                  + 10 ** (b - 3)
                  + 10 ** (b - 4)
                  + 10 ** (b - 5)
                  + 10 ** (b - 6)
                  + 10 ** (b - 7)
                  + 10 ** (b - 8)
                  + 10 ** (b - 9)
              )
          )
      )
  else:
      print(
          np.ceil(
              b
              * (
                  10**a
                  + 10 ** (a - 1)
                  + 10 ** (a - 2)
                  + 10 ** (a - 3)
                  + 10 ** (a - 4)
                  + 10 ** (a - 5)
                  + 10 ** (a - 6)
                  + 10 ** (a - 7)
                  + 10 ** (a - 8)
                  + 10 ** (a - 9)
              )
          )
      )
  
problem_description: 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?
samples: [{"input": "4 3", "output": "3333\n    \n\nWe have two strings `444` and `3333`. Between them, `3333` is the\nlexicographically smaller.\n\n* * *"}, {"input": "7 7", "output": "7777777"}]