Problem:


Score: 200 points

Problem Statement

Today, the memorable AtCoder Beginner Contest 100 takes place. On this occasion, Takahashi would like to give an integer to Ringo.

As the name of the contest is AtCoder Beginner Contest 100, Ringo would be happy if he is given a positive integer that can be divided by 100 exactly D times.

Find the N-th smallest integer that would make Ringo happy.

Constraints

D is 0, 1 or 2.

N is an integer between 1 and 100 (inclusive).

Input

Input is given from Standard Input in the following format:

D N

Output

Print the N-th smallest integer that can be divided by 100 exactly D times.

Sample Input 1

0 5

Sample Output 1

5

The integers that can be divided by 100 exactly 0 times (that is, not divisible by 100) are as follows: 1, 2, 3, 4, 5, 6, 7, ...

Thus, the 5-th smallest integer that would make Ringo happy is 5.  

Sample Input 2

1 11

Sample Output 2

1100

The integers that can be divided by 100 exactly once are as follows: 100, 200, 300, 400, 500, 600, 700, 800, 900, 1 \ 000, 1 \ 100, ...

Thus, the integer we are seeking is 1 \ 100.

Sample Input 3

2 85

Sample Output 3

850000

The integers that can be divided by 100 exactly twice are as follows: 10 \ 000, 20 \ 000, 30 \ 000, ...

Thus, the integer we are seeking is 850 \ 000.



Sample input:
0 5


Sample output:
5

Submission status: Accepted

Solution code:
D,N = map(int,input().split())

if N != 100:
    print(100**D*N)
else:
    print(101*100**D)

Submission status: Accepted

Solution code:
a,b=map(int,input().split())
if b == 100:
  print(101*(100**a))
else:
  print(b*(100**a))

Submission status: Accepted

Solution code:
d,n=map(int,input().split())
k=100**d
for i in range(1,n):
    k+=100**d
if n==100:
    k+=100**d
print(k)

Submission status: Accepted

Solution code:
D, N = map(int, input().split())
ans = N * 100**D
if N == 100:
    ans = str(ans)
    print('{}1{}'.format(ans[:2], ans[3:]))
else:
    print(ans)

Submission status: Accepted

Solution code:
d, n = map(int, input().split())
print(100 ** d * n if n != 100 else 101 * 100 ** d)

Submission status: Accepted

Solution code:
D, N = map(int, input().split()) 

candidate = []
i = 1
while len(candidate) != 100:
  if i % 100 != 0:
    candidate.append(i)
  i += 1

print(  candidate[N-1] * pow(100, D) )

Submission status: Accepted

Solution code:
D, N = map(int, input().split())

if N == 100:
    N = 101

print (N * 100 ** D)

Submission status: Accepted

Solution code:
data = list(map(int,input().split()))
if data[1] == 100:
        print(100**data[0]*101)
else:
        print(100**data[0]*data[1])

Submission status: Accepted

Solution code:
d,n=map(int,input().split())
if n < 100:
  print(n*(100**d))
else:
  print((n+1)*100**d)

Submission status: Accepted

Solution code:
a,b=map(int,input().split())
i=0
while b>0:
    i+=1
    if i%(100**a)==0 and i%(100**(a+1))!=0:
        b-=1
    
print(i)

Submission status: Accepted

Solution code:
D, N = map(int, input().split())

ans = N * (100 ** D)

if N == 100:
	ans += 100 ** D

print(ans)

Submission status: Accepted

Solution code:
d,n=map(int,input().split()) 
if n!=100:
  print(100**d*n)
else:
  print(100**d*(n+1))

Submission status: Accepted

Solution code:
D, N = map(int, input().split())
if N // 100:
    N += 1
print(100 ** D * N)

Submission status: Accepted

Solution code:
d, n = map(int, input().split())
if n == 100:
    print((100**d)*(n+1))
else:
    print((100**d)*n)

Submission status: Accepted

Solution code:
D, N = map(int, input().split())
if N == 100:
  N = N + 1
print(100**D*N)

Submission status: Accepted

Solution code:
d,n = map(int,input().split())
if n==100:
    n=101
print(n*100**d)

Submission status: Accepted

Solution code:
d, n = map(int, input().split())

print(100 ** d * (n + (n // 100)))

Submission status: Accepted

Solution code:
d,n=map(int,input().split())

if d==0 and n!=100:
  print(int(n))
elif d==0 and n==100:
  print(int(101))
  
elif d!=0 and n!=100:
  k=100**d
  print(int(k*n))
else:
  k=100**d
  print(int(k*101))

Submission status: Accepted

Solution code:

n, k = map(int, input().split())
k = k+1 if k==100 else k
print(100**n*k)

Submission status: Accepted

Solution code:
# 入力
D,N=map(int,input().split())

# D（=0,1,2）の値によって場合分け
if D==0:
  if N==100:
    print(101)
  else:
    print(N)

elif D==1:
  if N==100:
    print(10100)
  else:
    print(N*100)
else:
  if N==100:
    print(1010000)
  else:
    print(N*10000)

Submission status: Accepted

Solution code:
D, N = map(int, raw_input().split())
ans = ''
if N == 100: ans = '101'
else: ans = str(N)

for i in range(0, D):
	ans = ans + '00'
print ans

Submission status: Accepted

Solution code:
D,N = map(int,input().split())
if N == 100:
    print(101*(100**D))
else:
    print(N*(100**D))

Submission status: Accepted

Solution code:
d, n =  [ int(v) for v in input().split() ]
if n != 100:
	print(n*(100**d))
else:
	print(101*(100**d))

Submission status: Accepted

Solution code:
S = input().split()
D=int(S[0])
N=int(S[1])
Ncnt = N

cnt = 1
ans_list = []
if D == 0:
    cnt = 1
    while True:
        if cnt % 100 == 0:
            cnt += 1
        else:
            ans_list.append(cnt)
            if len(ans_list) == Ncnt:
                break
            else:
                cnt += 1
elif D == 1:
    cnt = 100
    while True:
        if cnt % 10000 == 0:
            cnt += 100
        else:
            ans_list.append(cnt)
            if len(ans_list) == Ncnt:
                break
            else:
                cnt += 100
elif D==2:
    cnt = 10000
    while True:
        if cnt % 1000000 == 0:
            cnt += 10000
        else:
            ans_list.append(cnt)
            if len(ans_list) == Ncnt:
                break
            else:
                cnt += 10000  
else:
    exit()

for ans in ans_list:
    temp_ans = ans

print(temp_ans)

Submission status: Accepted

Solution code:
d,n=map(int,input().split())
m=n+n//100
print((100**d)*m)

Submission status: Accepted

Solution code:
d, n = map(int, input().split())
if n == 100:
  output = pow(100, d) * 101
else:
  output = pow(100, d) * n
print(output)

Submission status: Accepted

Solution code:
[D,N]=list(map(int,input().split()
              )
          )
if N==100:
  print(100**D+100**(D+1))
elif D==0:
  print(N)
else:
  print(N*100**D)

Submission status: Accepted

Solution code:
D, N = map(int, input().split())
hyaku = N // 100
print(100 ** D * (N+hyaku))

Submission status: Accepted

Solution code:
D, N = map(int, input().split())
hyaku = N // 100
if D == 1:
  print(100 ** D * (N+hyaku))
elif D == 2:
  print(100 ** D * (N+hyaku))
else:
  print(100 ** D * (N+hyaku))

Submission status: Accepted

Solution code:
a, b = (int(i) for i in input().split()) 
if b == 100:b+=1
print((100**a)*b)

Submission status: Accepted

Solution code:
D, n = map(int, input().split())
if n == 100: n += 1
print(n*(100**D))

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys


def solve(D: int, N: int):
    n = N
    if n == 100:
        n = 101
    print(int((100**D)*n))


# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    D = int(next(tokens))  # type: int
    N = int(next(tokens))  # type: int
    solve(D, N)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
d, n = map(int, input().split())
if n!=100:
    print((100**d) * n)
else:
    print((100**d) * (n+1))

Submission status: Accepted

Solution code:
d,n = map(int, input().split())

divide = []

if d == 0:
    for i in range(1, 100):
        divide.append(i)    
    divide.append(101)
elif d == 1:
    for i in range(100, 10000, 100):
        divide.append(i)
    divide.append(10100)
    
else:
    for i in range(10000, 1000000, 10000):
        divide.append(i)
    divide.append(1010000)
print(divide[n - 1])

Submission status: Accepted

Solution code:
D,N = map(int,input().split())
t = N*(100**D)//100**(D+1)
g = (N+t)*(100**D)
print(g)

Submission status: Accepted

Solution code:
d,n=map(int,input().split())

if n%100==0:
    print((n+1)*100**d)
else:
    print(n*100**d)

Submission status: Accepted

Solution code:
D,N = map(int,input().split())
s = []
if N != 100:
    for i in range(1,101):
        s.append(i*(100**D))
    print(s[N-1])
else:
    print((100**D*101))

Submission status: Accepted

Solution code:
d,n=map(int, input().split())

if n == 100:
    print(100**d*(n+1))
else:
    print(100**d*(n))

Submission status: Accepted

Solution code:
d,n=map(int, input().split())
print(100**d*(n+1) if n==100 else 100**d*n)

Submission status: Accepted

Solution code:
d,n=map(int,input().split())
if n==100:
  print((n+1)*(100**d))
else:
  print((n)*(100**d))

Submission status: Accepted

Solution code:
import sys, os

f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
    sys.stdin = open('./input.txt', 'r')

def solve():
    d,n  = f()
    if n == 100:
        n+= 1
    print(n * 100**d)

solve()

Submission status: Accepted

Solution code:
D, N = map(int, input().split())
print(100 ** D * N if N != 100 else 100 ** D * 101)

Submission status: Accepted

Solution code:
d, n = map(int, input().split())
for i in range(3):
    if d == i:
        if n == 100:
            ans = 101*100**d
        else:
            ans = n*100**d
print(ans)

Submission status: Accepted

Solution code:
D,N=map(int,input().split())
F=100**D
if N<100:
  print(F*N)

else:
  print(F*101)

Submission status: Accepted

Solution code:
D,N = map(int,input().split())

if D == 0:
    if N == 100:
        print(101)
    else:
        print(N)
elif D == 1:
    if N == 100:
        print(10100)
    else:
        print(N*100)
elif D == 2:
    if N == 100:
        print(1010000)
    else:
        print(N * 10000)

Submission status: Accepted

Solution code:
C, N = map(int, input().split())
hund = N if N != 100 else 101
print((100**C)*hund)

Submission status: Accepted

Solution code:
a,b=list(map(int,input().split(" ")))
i=0
while b>0:
  i+=1
  if i%(100**a)==0 and i%(100**(a+1))!=0:
    b-=1
print(i)

Submission status: Accepted

Solution code:
d, n = map(int, input().split())
if n == 100:
    print(n*100**d + 100**d)
else:
    print(n * 100**d)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys


def solve(D: int, N: int):
    ret = (100 ** D) * N
    if N == 100:
        ret = (100 ** D) * (N + 1)
    print(ret)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    D = int(next(tokens))  # type: int
    N = int(next(tokens))  # type: int
    solve(D, N)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
###############################################################################

from sys import stdout
from bisect import bisect_left as binl
from copy import copy, deepcopy
from collections import defaultdict


mod = 1


def intin():
    input_tuple = input().split()
    if len(input_tuple) <= 1:
        return int(input_tuple[0])
    return tuple(map(int, input_tuple))


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


def intinl(count):
    return [intin() for _ in range(count)]


def modadd(x, y):
    global mod
    return (x + y) % mod


def modmlt(x, y):
    global mod
    return (x * y) % mod


def lcm(x, y):
    while y != 0:
        z = x % y
        x = y
        y = z
    return x


def combination(x, y):
    assert(x >= y)

    if y > x // 2:
        y = x - y

    ret = 1

    for i in range(0, y):
        j = x - i
        i = i + 1

        ret = ret * j
        ret = ret // i

    return ret


def get_divisors(x):
    retlist = []
    for i in range(1, int(x**0.5) + 3):
        if x % i == 0:
            retlist.append(i)
            retlist.append(x // i)
    return retlist


def get_factors(x):
    retlist = []
    for i in range(2, int(x**0.5) + 3):
        while x % i == 0:
            retlist.append(i)
            x = x // i
    retlist.append(x)
    return retlist


def make_linklist(xylist):
    linklist = {}
    for a, b in xylist:
        linklist.setdefault(a, [])
        linklist.setdefault(b, [])
        linklist[a].append(b)
        linklist[b].append(a)
    return linklist


def calc_longest_distance(linklist, v=1):
    distance_list = {}
    distance_count = 0
    distance = 0
    vlist_previous = []
    vlist = [v]
    nodecount = len(linklist)

    while distance_count < nodecount:
        vlist_next = []
        for v in vlist:
            distance_list[v] = distance
            distance_count += 1
            vlist_next.extend(linklist[v])
        distance += 1
        vlist_to_del = vlist_previous
        vlist_previous = vlist
        vlist = list(set(vlist_next) - set(vlist_to_del))

    max_distance = -1
    max_v = None
    for v, distance in distance_list.items():
        if distance > max_distance:
            max_distance = distance
            max_v = v

    return (max_distance, max_v)


def calc_tree_diameter(linklist, v=1):
    _, u = calc_longest_distance(linklist, v)
    distance, _ = calc_longest_distance(linklist, u)
    return distance


###############################################################################


def main():
    d, n = intin()

    if n == 100:
        print(101 * (100**d))
    else:
        print(n * (100**d))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
d, n = map(int, input().split())
if n == 100:
    print(n*100**d + 100**d)
else:
    print(n * 100**d)

Submission status: Accepted

Solution code:
D, N = map(int, input().split())

if N != 100:
    print((100 ** D) * N)
else:
    print((100 ** D) * 101)

Submission status: Accepted

Solution code:
D,N  = map(int, input().split())
if D == 0:
    if N != 100:
        print(N)
    if N == 100:
        print(101)
if D == 1:
    if N != 100:
        print(N * 100)
    if N == 100:
        print(10100)
if D == 2:
    if N != 100:
        print(N * 10000)
    if N == 100:
        print(1010000)

Submission status: Accepted

Solution code:
D,N = map(int,input().split())

if D == 0:
  if N == 100:
    print("101")
  else:
    print(N)
elif D == 1:
  if N == 100:
    print("10100")
  else:
    print(100*N)
else:
  if N == 100:
    print("1010000")
  else:
    print(10000*N)

Submission status: Accepted

Solution code:
A,B = [int(i) for i in input().split()]

if B != 100:
    print(100**A*B)
else:
    print(100**A*(B+1))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
# IMPORT ###############################################################################################################
import sys                                                      # システム
sys.setrecursionlimit(10**6)                                    # 再帰処理の上限変更
from collections import deque, Counter                          # キュー・個数カウント
from itertools   import accumulate, permutations, combinations  # 累積和・順列・組み合わせ
from operator    import itemgetter                              # ソート補助
from bisect      import bisect_left, bisect_right, bisect       # 二分探索
from heapq       import heappop, heappush                       # プライオリティキュー
from fractions   import gcd                                     # 最大公約数
from math        import ceil, floor, sqrt, cos, sin, tan, pi    # 数学処理
from copy        import deepcopy                                # オブジェクトコピー
import numpy         as np                                      # 数値計算

# MAIN #################################################################################################################
def main():
    # Init #############################################################################################################
    im = InputManager()
    # Input ############################################################################################################
    d, n = im.inputMultiple()
    # Logic ############################################################################################################
    message = ""
    if n == 100:
        message += "101"
    else:
        message += str(n)
    for i in range(d):
        message += "00"
    # Output ###########################################################################################################
    print(message)
    # Return ###########################################################################################################
    return

# INPUT MANAGER ########################################################################################################
class InputManager(object):
    def __init__(self):
        pass

    @staticmethod
    def inputSingle(dtype=int):
        return dtype(input())
    
    @staticmethod
    def inputMultiple(dtype=int, aslist=False):
        if aslist:
            return list(map(dtype, input().split()))
        else:
            return map(dtype, input().split())

    @staticmethod
    def input2D(h, dtype=int):
        return [list(map(dtype, input().split())) for i in range(h)]

# CALL MAIN ############################################################################################################
main()

Submission status: Accepted

Solution code:
d,n = map(int, input().split())
r = 0
if n == 100:
    if d == 0:
        print( 1 * 101)
    elif d == 1:
        print( 100 * 101)
    elif d == 2:
        print( 100*100 * 101)
else:
    if d == 0:
        print(n * 1)
    elif d == 1:
        print(n * 100)
    elif d == 2:
        print(n * 100*100)

Submission status: Accepted

Solution code:
d,n=map(int,input().split())
if(n<100):
    print(100**d*n)
else:
    print(100**d*101)

Submission status: Accepted

Solution code:
D, N = map(int, input().split())
print((100 ** D) * N if N != 100 else (100 ** D) * (N + 1))

Submission status: Accepted

Solution code:
d,n=map(int,input().split())
if n!=100:
    print(n*100**d)
else:
    print(n*100**d+n*100**d//100)

Submission status: Accepted

Solution code:
D, N = map(int, input().split())
num = 100**D
if num == 1:
    print(N if N != 100 else 101)
else:
    print(num*N if N != 100 else num*(N+1))

Submission status: Accepted

Solution code:
dn=list(map(int,input().split()))
d=dn[0]
n=dn[1]
if n<100:
    print(n*100**d)
else:
    if d==0:
        print(101)
    elif d==1:
        print(10100)
    else:
        print(1010000)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
# input
d, n = map(int, input().split())

ans = (100 ** d) * (n + n // 100)
print(ans)

Submission status: Accepted

Solution code:
D,N=map(int,input().split())
if N<100:
    print((100**D)*N)
else:
    print((100**D)*101)

Submission status: Accepted

Solution code:
def B(S):
    D,N = map(int,S.split())
    print(100**D*(N if N!=100 else 101))

B(input())

Submission status: Accepted

Solution code:
D, N = map(int, input().split())

print(100**D * (N if N != 100 else 101))

Submission status: Accepted

Solution code:
D, N = map(int, input().split())

n = 0
count = 0
while True:
    n += 100**D
    target = n
    count_div = 0
    while True:
        if target % 100 == 0:
            count_div += 1
            target //= 100
        else:
            break
    if count_div == D:
        count += 1

    if count == N:
        print(n)
        exit()

Submission status: Accepted

Solution code:
D, N = map(int, input().split())

n = 100**D
count = 0
while True:
    target = n
    count_div = 0
    while True:
        if target % 100 == 0:
            count_div += 1
            target //= 100
        else:
            break
    if count_div == D:
        count += 1

    if count == N:
        print(n)
        exit()

    n += 100**D

Submission status: Accepted

Solution code:
D, N = map(int, input().split())

if D == 0 and N == 100:
    print(101)
elif D == 1 and N == 100:
    print(10100)
elif D == 2 and N == 100:
    print(1010000)
else:
    print(100**D*N)

Submission status: Accepted

Solution code:
d,n = map(int,input().split())
if n != 100:    
    print(100**d*n)
else:
    print(100**d*101)

Submission status: Accepted

Solution code:
from itertools import *
d, n = map(int, input().split())
ite = (x * 100 ** d for x in count() if x % 100 != 0)
print(next(islice(ite, n - 1, None)))

Submission status: Accepted

Solution code:
from itertools import *
d, n = map(int, input().split())
delta = 100 ** d
ite = (x * delta for x in count() if x % 100 != 0)
print(next(islice(ite, n - 1, None)))

Submission status: Accepted

Solution code:
from itertools import *
d, n = map(int, input().split())
delta = 100 ** d
ite = (x for x in count(delta, delta) if x % (delta * 100) != 0)
print(next(islice(ite, n - 1, None)))

Submission status: Accepted

Solution code:
from itertools import *
d, n = map(int, input().split())
delta = 100 ** d
ite = (x for x in count(delta, delta) if x % (delta * 100) != 0)
print(list(islice(ite, n - 1, n))[0])

Submission status: Accepted

Solution code:
from itertools import *

def nth(iterable, n, default=None):
    "Returns the nth item or a default value"
    return next(islice(iterable, n, None), default)

D, N = map(int, input().split())
delta = 100 ** D
ite = (x for x in count(delta, delta) if x % (delta * 100) != 0)
print(nth(ite, N - 1))

Submission status: Accepted

Solution code:
d,n=map(int,input().split());print([pow(100,d)*n,pow(100,d)*101][n==100])

Submission status: Accepted

Solution code:
# -*- coding:utf-8 -*-

def solve():
    D, N = list(map(int, input().split()))

    if N != 100:
        ans = (100**D)*N
    else:
        ans = (100**D)*101
    
    print(ans)


if __name__ == "__main__":
    solve()

Submission status: Accepted

Solution code:
d, n = [int(i) for i in input().split()]
if n == 100:
  print((n+1)*(100**d))
else:
  print(n*(100**d))

Submission status: Accepted

Solution code:
D,N=map(int,input().split())
if N==100:
  N=101
print((100**D)*N)

Submission status: Accepted

Solution code:
d,n = map(int,input().split())
if n!=100:
    if d==0:
        print(n)
    elif d == 1:
        print(n*100)
    else:
        print(n*10000)
if n==100:
    print(101*(100)**d)

Submission status: Accepted

Solution code:


def main():
    a, b = map(int, input().split())
    if b == 100:
        b = 101
    print((100 ** a) * b)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
D,N=map(int,input().split())
print(100**D*N if N!=100 else 100**D*(N+1))

Submission status: Accepted

Solution code:
d,n=map(int,input().split())
print((100**d)*n if n!=100 else (100**d)*n+100**d)

Submission status: Accepted

Solution code:
d,n=map(int,input().split())
if n!=100:
  print(100**d*n)
else:
  print(100**d*(n+1))

Submission status: Accepted

Solution code:
def main():
    d, n = map(int, input().split())

    if n == 100:
        n += 1
    if d == 0:
        print(n)
    else:
        print(100**d*n)

if __name__=='__main__':
    main()

Submission status: Accepted

Solution code:
d,n=map(int,input().split())
if n==100:
  n=-~n
print(n*100**d if d>0else n)

Submission status: Accepted

Solution code:
d,n=map(int,input().split())
print((100**d)*(n+n//100))

Submission status: Accepted

Solution code:
D,N = map(int,input().split())
from math import pow
print(int(pow(100,D) * N)) if N != 100 else print(int(pow(100,D) * 101))

Submission status: Accepted

Solution code:
def main():
  D, N = [int(x) for x in input().split()]
  if N == 100:
    print((N + 1) * (100**D))
  else:
    print(N * (100**D))


if __name__ == "__main__":
  main()

Submission status: Accepted

Solution code:
from sys import stdin

D, N = [int(x) for x in stdin.readline().rstrip().split()]

if N == 100:
    print(101 * 100 ** D)
else:
    print(N * 100 ** D)

Submission status: Accepted

Solution code:
import sys
d,n = list(map(int, input().split()))
if d == 1:
    print((n+(n == 100))*100)
elif d == 2:
    print((n+(n == 100))*100*100 )
else:
    print(n if n != 100 else 101)

Submission status: Accepted

Solution code:
d,n=map(int,input().split())
a=[]
for i in range(1,100):
    a.append(i*100**d)
a.append(101*100**d)
a.append(102*100**d)
print(a[n-1])

Submission status: Accepted

Solution code:
d,n=map(int,input().split())
if d==0 and n==100:
  print(101)
else:
  if n==100:
    n=n+1
  print((100**d)*n)

Submission status: Accepted

Solution code:
D, N = map(int, input().split())
print((N + (N == 100)) * 100 ** D)

Submission status: Accepted

Solution code:
def read_input():
	d, n = map(int, input().split())
	return d, n
	
def submit():
	d, n = read_input()
	
	base = 100**d
	if n < 100:
		print(base*n)
	else:
		print(base*(n + 1))
	
submit()

Submission status: Accepted

Solution code:
d, n = map(int, input().split())
print(100 ** d * (n if n != 100 else n + 1))

Submission status: Accepted

Solution code:
D, N = map(int, input().split())

if D == 0:
    if N != 100:
        print(N)
    else:
        print(101)
elif D == 1:
    if N != 100:
        print(100*N)
    else:
        print(100*(N+1))
else:
    if N != 100:
        print(10000*N)
    else:
        print(10000*(N+1))

Submission status: Accepted

Solution code:
D,N=map(int,input().split())
if D==0:
    if N==100:
        print(101)
    else:
	    print(N)
elif D==1:
    if N==100:
        print(10100)
    else:
	    print(100*N)
elif D==2:
    if N==100:
        print(1010000)
    else:
	    print(10000*N)

Submission status: Accepted

Solution code:
d,n=map(int,input().split())
if n == 100:
    n = 101
print((100**d)*n)

Submission status: Accepted

Solution code:
d,n=map(int,input().split())
if n==100:n=101
print(100**d*n)

Submission status: Accepted

Solution code:
d,n=map(int,input().split())
if n==100:
	print(100**d*n+100**d)
else:
	print(100**d*n)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import numpy as np
import math
import re

x = input()
x = re.split(" ",x)
D = int(x[0])
N = int(x[1])

if (N==100):
  print(100**D*N+100**D)
else:
  print(100**D*N)

Submission status: Accepted

Solution code:
D,N = map(int,input().split())

if N==100:
  print(100**D*N+100**D)
else:
  print(100**D*N)

Submission status: Accepted

Solution code:
D,N = map(int,input().split())

if N==100:
  print(100**D*N+100**D)
else:
  print(100**D*N)

Submission status: Accepted

Solution code:
d,n = map(int,input().split())
if n == 100:
    print(100**d * 101)

else:
    print(100**d * n)

Submission status: Accepted

Solution code:
d,n = map(int, input().split())

if d == 0:
    if n <= 99:
        print(n)
    else:
        print(101)
if d == 1:
    if n <= 99:
        print(n*100)
    else:
        print(10100)
if d == 2:
    if n <= 99:
        print(n*10000)
    else:
        print(1010000)

Submission status: Accepted

Solution code:
D, N = map(int, input().split())
if N == 100:
	print((100 ** D) * (N + 1))
else:
	print((100 ** D) * N)

Submission status: Accepted

Solution code:
D, N = list(map(int, input().split()))
print(101*(100**D) if N==100 else N * 100**D)

Submission status: Accepted

Solution code:
d, n = map( int, input().split() )
if n != 100 :
    print(100 ** d * n)
else :
    print(100 ** d * 101)

Submission status: Accepted

Solution code:
d, n = map(int, input().split())
if n < 100:
    print(n * 100**d)
else:
    print((n+1) * 100**d)

Submission status: Accepted

Solution code:
d, n = list(map(int, input().split()))
print((100**d)*(n + n//100))

Submission status: Accepted

Solution code:
D,N=map(int,input().split())
if N==100:
    print(N*100**D+100**D)
    quit()
print(N*100**D)

Submission status: Accepted

Solution code:
d, n = map(int, input().split())
if n==100:
  print((100**d)*101)
else:
  print((100**d)*n)

Submission status: Accepted

Solution code:
D, N = map(int,input().split())
if N == 100:
    print((100**D)*101)
else:
    print((100**D)*N)

Submission status: Accepted

Solution code:
d,n = map(int,input().split())
if n != 100 :
    print(100**d*n)
else :
    print(100**d*101)

Submission status: Accepted

Solution code:
[D,N] = list(map(int,input().split()))
if N == 100:
  print(101*(100**D))
else:
  print(N*(100**D))

Submission status: Accepted

Solution code:
D,N = map(int,input().split())
if N < 100: 
    print(100**D*N)
elif N == 100:
    print(100**D*(N+1))

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

d, n = map(int, input().split())

x = 100 ** d

if n == 100:
    print(x * 101)
else:
    print(x * n )

Submission status: Accepted

Solution code:
D,N = map(int,input().split())
if N == 100:
    print((100 ** D) * 101)
else:
    print((100 ** D) * N)

Submission status: Accepted

Solution code:
d, n = [int(c) for c in input().split()]

if d == 0:
    if n == 100:
        print(101)
    else:
        print(n)
elif d == 1:
    if n == 100:
        print(101 * 100)
    else:
        print(n * 100)
else:
    if n == 100:
        print(101 * 10000)
    else:
        print(n * 10000)

Submission status: Accepted

Solution code:
d,n = [int(i) for i in input().split()]

if n == 100:
    print(100**d*(n+1))
else:
    print(100**d*n)

Submission status: Accepted

Solution code:
d,n=map(int,input().split())
if n==100:
    n+=1
if d==0:
    print(n)
elif d==1:
    print(100*n)
elif d==2:
    print(10000*n)

Submission status: Accepted

Solution code:
import sys

D, N = map(int, input().split())

if D == 0:
    if N == 100:
        print(101)
    else:
        print(N)
        
if D == 1:
    if N == 100:
        print(10100)
    else:
        print(N * 100)
    
if D == 2:
    if N == 100:
        print(1010000)
    else:
        print(N * 10000)

Submission status: Accepted

Solution code:
num = list(map(int,input()
.split()))
if num[1] !=100:
    if num[0] == 0:
        ans = num[1]
    elif num[0] == 1:
        ans = num[1]*100
    elif num[0] == 2:
        ans = num[1]*10000
else:
    if num[0] == 0:
        ans = num[1]+1
    elif num[0] == 1:
        ans = num[1]*100+100
    elif num[0] == 2:
        ans = num[1]*10000+10000

print(ans)

Submission status: Accepted

Solution code:
# ABC100B - Ringo's Favorite Numbers
d, n = list(map(int, input().rstrip().split()))
print(100 ** d * n if n <= 99 else 100 ** d * 101)

Submission status: Accepted

Solution code:
D,N= (int(i) for i in input().split())
print(N*(100**D)) if N!=100 else print(101*(100**D))

Submission status: Accepted

Solution code:
import sys
import numpy as np

readInt = lambda: int(sys.stdin.readline())
readIntN = lambda: [int(v) for v in sys.stdin.readline().split(' ')]

d, n = readIntN()
if n == 100:
    n = 101
ret = n * (100 ** d)
print(ret)

Submission status: Accepted

Solution code:
import sys

d, n = map(int, input().split())
ans = 0

if n == 100:    
    print(100 ** d * 101) 
else:
    print(100 ** d * n)

Submission status: Accepted

Solution code:
D, N = map(int, input().split())
print((100 ** D) * (N + N // 100))

Submission status: Accepted

Solution code:
D, N = map(int, input().split())
if N % 100 == 0:
  N += 1
s = pow(100, D) * N
print(s)

Submission status: Accepted

Solution code:
D, N = map(int, input().split())

if N == 100:
  print('101'+'00'*D)
  exit()

#Nが1～99の場合
print(str(N)+'00'*D)

Submission status: Accepted

Solution code:
d, n = map(int, input().split())
ans = 100**d * (n+n//100)
print(ans)

Submission status: Accepted

Solution code:
d,n=map(int,input().split())
print(str(n)+"00"*d if n<100 else "101"+"00"*d)

Submission status: Accepted

Solution code:
d,n=map(int,input().split())
if n!=100:
    print((100**d)*n)
else:
    print((100**d)*101)

Submission status: Accepted

Solution code:
def main():
	D, N = map(int, input().split())
	if N == 100:
		N += 1
	print(N * (100**D))

if __name__ == '__main__':
	main()