Problem:
 Score : 200 points    Problem Statement  Takahashi has a deposit of 100 yen (the currency of Japan) in AtCoder Bank.  The bank pays an annual interest rate of 1 % compounded annually. (A fraction of less than one yen is discarded.)  Assuming that nothing other than the interest affects Takahashi's balance, in how many years does the balance reach X yen or above for the first time?      Constraints   101 \le X \le 10^{18}  All values in input are integers.         Input  Input is given from Standard Input in the following format:  X       Output  Print the number of years it takes for Takahashi's balance to reach X yen or above for the first time.        Sample Input 1 103      Sample Output 1 3   The balance after one year is 101 yen.  The balance after two years is 102 yen.  The balance after three years is 103 yen.   Thus, it takes three years for the balance to reach 103 yen or above.       Sample Input 2 1000000000000000000      Sample Output 2 3760       Sample Input 3 1333333333      Sample Output 3 1706

Solution (Python):
x=int(input())
y=100
for i in range(1,10000):
  y=int(y*1.01)
  if x<=y:
    print(i)
    break

Solution (Python):
X = int(input())

dep = 100
y = 0

while dep < X:
  y += 1
  dr = int(dep * 0.01)
  dep += dr

print(y)

Solution (Python):


X=int(input())

Y=100
ans=0
while(1):
    ans+=1
    Y=Y+int(Y*0.01)
    
    if Y>=X: break

print(ans)

Solution (Python):
X = input()
Money = 100
counter = 0

while int(X) > Money:
    Money = int(Money*1.01)
    counter = counter + 1
print(counter)

Solution (Python):
import math

x = int(input())
y = 100

for i in range(4000):
    y *= 1.01
    y = math.floor(y) 
    if(y >= x):
      print(i+1)
      exit()

Solution (Python):
import sys
import math
k =int(input())
p=100.0
for i in range (1,sys.maxsize):
    p = math.floor(p*1.01)
    if p >= k:
        print(i)
        break;

Solution (Python):
X=int(input())
m=100
n=0
while True:

    if m>=X:
        print(n)
        exit()
    else:
        n+=1
        m=int(m*1.01)

Solution (Python):
import math
x = int(input())


m = 100
n = 0
while m < x:
  m = m + math.floor(m*0.01)
  n+=1
  
print(n)

Solution (Python):
import math
X = int(input())
a, b = 100, 1
while 1:
    a += math.floor(a * 0.01)
    if a >= X:
        print(b)
        break
    b += 1

Solution (Python):
x = int(input())
coin=100
counter=0
while(True):
  coin=int(coin*1.01)
  counter=counter+1
  if coin>=x:
    print(counter)
    break

Solution (Python):
import math
m = input()

s = 100
c = 0
count = 1
for i in range(100, int(m)):
  c = s * 0.01
  s = s + math.floor(c)
  if s >= int(m):
    print(count)
    break
  count = count + 1

Solution (Python):
end = int(input())
num = 100
for i in range(10**19):
    plus = num * 0.01
    plus = int(plus)
    num += plus
    if num >= end:
        print(i+1)
        break

Solution (Python):
x = int(input())
c = 100
cnt = 0
while(1):
    c = int(c * 1.01)
    cnt += 1
    if c >= x:
        break

print(cnt)

Solution (Python):
import math
X=int(input())
a=100
b=0
while a<X:
  a=math.floor(a*1.01)
  b += 1
print(b)

Solution (Python):
import math
if __name__ == '__main__':
    
    X = int(input())
    
    acc = 100
    for i in range(3800):
        acc *= 1.01
        acc = math.floor(acc)

        if(acc >= X):
            print(i+1)
            exit()

Solution (Python):
import math
X = int(input())
money = 100
t = 1
for i in range(X):
    money += math.floor(money * 0.01)
    if money >= X:
        print(t)
        break
    t += 1

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from math import floor
def main():
    x = int(readline())
    a = 100
    i = 0
    while a < x:
        a =  floor(a*(1.01))
        i+=1
    print(i)
if __name__ == '__main__':
    main()

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
from operator import mul


sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007

x = I()
ret = 100
for i in range(10000):
    ret = int(ret * 1.01)
    if ret >= x:
        print(i + 1)
        break

Solution (Python):
x = int(input())
ans = 100
i = 0
while ans < x:
    ans *= 1.01
    ans = int(ans)
    i += 1
print(i)

Solution (Python):
import sys
import math
input = lambda:sys.stdin.readline().strip()
x = int(input())
p = 100
ans = 0
while p<x:
    ans+=1
    p*=(1.01)
    p = math.floor(p)
print(ans)

Solution (Python):
import math

X = int(input())

N = 1
updated = 100
while True:
    money = math.floor(updated * 1.01)
    updated = money 
    if money >= X:
        break
    else:
        N += 1

print(N)

Solution (Python):
import math

if __name__ == "__main__":
    X = int(input())
    en = 100
    cnt = 0
    while en < X:
        en = en + math.floor(en * 0.01)
        cnt += 1
    print(cnt)

Solution (Python):
import math

a = int(input())
b = 100
i = 0
c = 0.01
for i in range(a):
  b += (b * c)
  i+=1
  b = math.floor(b)
  if b>=a:
  		print(i)
  		break

Solution (Python):
n = int(input())
i = 100
c = 0
while n > i:
    i *= 1.01
    i //= 1
    c +=1
print(c)

Solution (Python):
a = 100
x = int(input())

for i in range(10**18):
    a = int(a * (1.01))
    if a >= x:
        print(i+1)
        break

Solution (Python):
import math
x = int(input())

ans = 100
n = 1
while True:
    ans *= 1.01
    ans = math.floor(ans)
    if ans >= x:
        print(n)
        break
    n += 1

Solution (Python):
import math

X = int(input())

o = 100
y = 0

while(o < X):
  o = math.floor(o * 1.01)
  y += 1

print (y)

Solution (Python):
x = int(input())
count = 0
y= 100
for i in range(3761):
  y=(y*1.01)//1
  count+=1
  if y>=x:
    print(count)
    break

Solution (Python):
a = int(input())
year = 0
init_yen = 100
while init_yen < a:
    init_yen *= 1.01
    init_yen = int(init_yen)
    year+=1

print(year)

Solution (Python):
import math

x = int(input())
m = 100

for i in range(1, 1000000000000000000):
  m = math.floor(m * 1.01)
  if m >= x:
    print(i)
    break

Solution (Python):
X = int(input())
current = 100
year = 0
while current < X :
    fraction = current*0.01
    if fraction >= 1 :
        current = current + int(fraction)
        year = year + 1
print(year)

Solution (Python):
import math

num_year = 0
t_maney = 100
x = int(input())

while t_maney < x:
    num_year += 1
    t_maney = math.floor(t_maney*1.01)

print(num_year)

Solution (Python):
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate


def read_ints():
    return list(map(int, read().split()))


def read_a_int():
    return int(read())


def read_tuple(H):
    '''
    H is number of rows
    '''
    ret = []
    for _ in range(H):
        ret.append(tuple(map(int, read().split())))
    return ret


def read_col(H):
    '''
    H is number of rows
    A列、B列が与えられるようなとき
    ex1)A,B=read_col(H)    ex2) A,=read_col(H) 
    '''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return tuple(map(list, zip(*ret)))


def read_matrix(H):
    '''
    H is number of rows
    '''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return ret
    


MOD = 10**9 + 7
INF = 2**31  

from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right  
from math import gcd

a = 100
X = read_a_int()
ans = 0
while a < X:
    a = int(a * 1.01)
    ans += 1
print(ans)

Solution (Python):
X = int(input())
Y = 100
year = 0
while Y < X:
    Y = int(Y * 1.01)
    year = year + 1
print(year)

Solution (Python):
X = int(input())

m = 100
count = 0
while True:
    m = int(m * 1.01)
    count += 1
    if m >= X:
        break
print(count)

Solution (Python):
import math

X = int(input())
save_money = 100

for ans_year in range(1, X):
    save_money = math.floor(save_money * 1.01)
    if X <= save_money:
        print(ans_year)
        break

Solution (Python):
import math
X = int(input())
K = 0
L = 100
while L < X:
    K += 1
    L = math.floor(L * 1.01)
print(K)

Solution (Python):
X = int(input())

A = 100
cnt = 0

while A < X:
    A = int(A * 1.01)
    cnt += 1

print(cnt)

Solution (Python):
X = int(input())
C = 100
year = 0
while C < X:
    plus = int(C / 100)
    C += plus
    year += 1
print(year)

Solution (Python):
X = int(input())

r = 0.01
s = 100
for i in range(X):
    s=int(s * (1 + r))
    if (s >= X):
        print(i+1)
        break

Solution (Python):
X = int(input())
P=100
Y=0

while(1):
    Y=Y+1
    P=P+int(P*0.01)
    if X <= P:
        print(Y)
        break

Solution (Python):
X = int(input())
current = 100
year = 0
while current < X:
    fraction = current * 0.01
    if fraction >= 1:
        current = current + int(fraction)
        year = year + 1
print(year)

Solution (Python):
x = int(input())
y = 0
amt = 100
while amt < x:
    amt += (amt//100)
    y += 1

print(y)

Solution (Python):
z = int(input())

a = 100
n = 0
for i in range(1000000):
  b = a*1.01
  a = b//1
  n = n + 1
  if a >= z:
    break
print(n)

Solution (Python):
import math

X = int(input())

m = 100
i = 0
while 1:
    m = math.floor(m * 1.01)
    i += 1
    if m >= X:
        break
print(i)

Solution (Python):
import math
X=int(input())
n=100
i=0
N=100
while N<X:
  n=N*1.01
  N=math.floor(n)
  i+=1
  
print(i)

Solution (Python):
X = int(input())
current = 100
year = 0
while current < X :
    fraction = current*0.01
    if fraction >= 1 :
        current = current + int(fraction)
        year = year + 1
print(year)

Solution (Python):
X=int(input())
a=100
count=0
while a<X:
    a=a*1.01//1
    count+=1
print(count)

Solution (Python):
x = int(input())

10**18 // 100*101

temp = 100

for i in range(1039999999999999999):
    temp = temp * 1.01 // 1
    
    if temp >= x:
        print(i+1)
        break

Solution (Python):
import math
X=int(input())
A=100
count=0

while A < X:
    A=math.floor(A*1.01)
    count+=1
else:
    print(count)

Solution (Python):
X = int(input())
i = int(100)
y = 0
while i < X:
    y += 1
    i = int(i * 1.01)
print(y)

Solution (Python):
de = 100
y = 0
X = int(input())
while de < X:
    frac = de * 0.01
    if frac >= 1:
        de = de + int(frac)
        y = y + 1
print(y)

Solution (Python):
final_amt = int(input())
has = 100
rate = 1
for i in range(1, 3761):
    has += ((has * 1) // 100)
    
    if has >= final_amt:
        break
print(i)

Solution (Python):
x = int(input())
a = 100
i = 0
while a < x:
  i += 1
  a = int(a * 1.01)
print(i)

Solution (Python):
to = int(input())
ini = 100
t = 0
while ini < to:
    ini = ini + (ini // 100)
    t += 1
print(t)

Solution (Python):
import math

X = input()

amount = 100
year = 0
while int(X) > amount:
    amount = int(amount * 1.01)
    
    year += 1

print(year)

Solution (Python):
import math
X = int(input())
mon = 100
for num in range (1,999999999999999900):
    mon = mon + math.floor(mon*0.01)

    if mon >= X : break

print(num)

Solution (Python):
x = int(input())
cnt = 0
sum = 100
while x > sum:
    cnt += 1
    sum += int(sum*0.01)
print(cnt)

Solution (Python):
import time
import math
x = int(input())
money = 100
count = 0
while x>money:
  money = math.floor(money*1.01)
  count += 1
print(count)

Solution (Python):
import math
x = int(input())
year = 0
a = 100
while a < x :
    a = math.floor(a * 1.01)
    year += 1
print(year)

Solution (Python):
n = int(input())

cnt = 0
m = 100
while m < n :
    m =  int(m * 1.01)
    cnt += 1

print(cnt)

Solution (Python):
x = int(input())
a = 100
for i in range(1, 3761):
    a = int(a * 1.01)
    if a >= x:
        print(i)
        exit(0)

Solution (Python):
import math

X = int(input())
K = 100
cnt = 0
while 1:
	cnt += 1
	K = math.floor(K * 1.01)
	if K >= X:
		print(cnt)
		break

Solution (Python):



def main():
    X = int(input())
    
    m = 100
    c = 0
    while m < X:
        m = int(m * 1.01)
        c += 1
    print(c)

if __name__ == "__main__":
    main()

Solution (Python):
import math
X = int(input())

n = 1
M = 100

while math.floor(M*1.01) < X:
    n += 1
    M = math.floor(M*1.01)
    
print(n)

Solution (Python):
n = int(input())

ginko = 100
count = 0

while True:
    ginko += ginko // 100
    count += 1
    if ginko >= n:
        print(count)
        break

Solution (Python):
import math
a = 100.0
x = float(input())
i = 0
while a<x:
  a *= 1.01
  b = math.floor(a)
  a = float(b)
  i += 1
print(i)

Solution (Python):
X = int(input())

ans = 100
count = 0
while ans < X:
    ans += int(ans * 0.01)
    count += 1

print(count)

Solution (Python):
import math as mt
X = float(input())
t = 100.0
k = 100
a = 0
while True:
    if k < X:
        a += 1
        t = float(k)
        t *= 1.01
        k = mt.floor(t)

    else:
        break
print(a)

Solution (Python):
target = int(input())
money = 100
years = 0
while money < target:
  money = int(money*1.01)
  years += 1
  
print(years)

Solution (Python):
import math
n=int(input())
a=100
t=1
while(a<n):
    a=int(a+a*0.01)
    t+=1
print(t-1)

Solution (Python):
x = int(input())
a = 100
ans = 0
for i in range(10**7):
    ans += 1
    a *= 1.01
    a = int(a)
    if a >= x :
        break
print(ans)

Solution (Python):
import math
import sys
def risoku(k):
  return(k+k//100)
x=int(input())
min=math.floor(math.log(x//100,1.01))
k=100
for i in range(min):
  k=risoku(k)
for i in range(min,3761):
  k=risoku(k)
  if (k>=x):
    print(i+1)
    sys.exit()

Solution (Python):
import math

x = int(input())
s = 101
cnt = 1

while 1:
    if s < x:
        s = math.floor(s*1.01)
        cnt += 1
    else:
        print(cnt)
        break

Solution (Python):

X = int(input())
money = 100
count = 0
while money < X:
    money = money * 1.01
    count += 1
    money = int(money)
print(count)

Solution (Python):
import math

x = int(input())
y = 100
ans = 0
while x > y:
    y = math.floor(y*1.01)
    ans += 1

print(ans)

Solution (Python):
import math

x = int(input())
money = 100
year = 0

while money < x:
  money = math.floor(money*1.01)
  year += 1
print(year)

Solution (Python):
X = int(input())

ans = 100
count = 0

while ans < X:
    ans = int(ans * 1.01)
    count += 1
    if ans >= X:
        print(count)

Solution (Python):

import math
x=int(input())
a=100
b=1
while(1):
    a=math.floor(a*1.01)
    if (a>=x):
        print(b)
        break
    b+=1

Solution (Python):
INT_MAX=10**11+7
MOD=10**9+7
def INPUT():return list(int(i) for i in input().split())
def LIST_1D_ARRAY(n):return [0 for _ in range(n)]
def LIST_2D_ARRAY(m,n):return [[0 for _ in range(n)]for _ in range(m)]

import math as M
x=int(input())
p=100
years=0
while(p<x):
    p+=int(p/100)
    years+=1
print(years)

Solution (Python):
x = int(input())
y = 100
i=0
while True:
	y = y + int(0.01*y)
	i += 1
    
	if y >= x:
		print(i)
		break

Solution (Python):
import math
x = int(input())

x_cnt = 100
cnt = 0
while(x_cnt < x):
    x_cnt = math.floor(x_cnt * 1.01)
    cnt += 1

print(cnt)

Solution (Python):
import math

X = int(input())
ans = 100
cnt = 0

while True:
    ans = ans*1.01
    ans = math.floor(ans)
    cnt += 1
    if X <=ans:
        print(cnt)
        exit()

Solution (Python):
import math
X = int(input())
Z = 100
res = 0
while (X > Z):
     Z += Z*0.01
     Z = math.floor(Z)
     res += 1 
print(res)

Solution (Python):
m = 100
year=0
target=int(input())
while m<int(target):
    m=int(m*1.01)
    year+=1

print(year)

Solution (Python):
x=int(input())
import math
yokin=100
risi=0
for i in range(1,x+1-100):
  risi=int(yokin*0.01)
  yokin+=risi
  if yokin >= x:
    print(i)
    break

Solution (Python):
import math 
x = int(input())
y = 100
i = 1
while( y< x):
    
    y = y*(1.01)
    y = math.floor(y)
    i += 1
print(i-1)

Solution (Python):
n = int(input())

p = 0.01
kane = 100
c = 0
while True:
    if n <= kane:break
    c += 1
    kane += int(kane*p)

print(c)

Solution (Python):


x=int(input())
money=[100]
i=0
while True:
    new = int(money[i]*1.01)
    money.append(new)
    i+=1
    if money[-1]>=x:
        print(i)
        break
    else:
        continue

Solution (Python):
x = int(input())
a = 100
i = 1
while(1):
    a = int(a + 0.01*a)
    if (a>=x):
        print(i)    
        break
    i +=1

Solution (Python):
x = int(input())
money = 100
num = 1 / 100
count = 0

while money < x:
  money = int(money + (money * num))
  count = count + 1
else:
  print(count)

Solution (Python):
import math
N = int(input())

s=100
count=0

while N > s:
    s*=1.01
    s=math.floor(s)
    count+=1
print(count)

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 9)

x = int(input())

def per(year):
  if year == 0:
    return 100
  else:
    return int(per(year-1) * 1.01)
  
year = 0
while True:
  if per(year) >= x:
    print(year)
    break
  else:
    year += 1

Solution (Python):
from decimal import Decimal
import math
X = int(input())

start = Decimal("100")

risi = Decimal("1.0100000")
year = 1

while(True):
    start = math.floor(Decimal(start) * Decimal(risi))
    
    if(start >= X):
        break
    year += 1
    
    
print(year)

Solution (Python):


from sys import stdin, stdout

if __name__ == "__main__":
    x = stdin.readline()
    x = int(x)

    curr = 101
    ans = 1

    while curr < x:
        curr *= 101
        curr //= 100
        ans += 1
    
    stdout.write(str(ans) + '\n')

Solution (Python):
X=int(input())
m=100
cnt=0
while True:
    cnt+=1
    m=int(m*1.01)
    if m>=X:
        break
print(cnt)

Solution (Python):
import numpy as np

def main():
    x = int(input())
    money = 100
    ans = 0
    while x > money:
        money += money * 0.01
        ans += 1
        money = np.floor(money)
        
        
    
    print(ans)

if __name__ == '__main__':
    main()

Solution (Python):
from math import *
x=int(input())

p=100

for i in range(1,10000000):
	p=p+(p//100)
	if p>=x:
		print(i)
		break

Solution (Python):
import math
X=int(input().strip())

x=100
i=0
while(x < X):
    x = math.floor(x*1.01)
    i+=1
print(i)

Solution (Python):
X = int(input())

cnt = 0
y = 100
while True:
    cnt += 1
    y = int(y * 0.01) + y
    if y >= X:
        print(cnt)
        break

Solution (Python):
import math

x = int(input())
m = 100
r = 0.01

y = 1

while True:
    m=m+m*r
    m=math.floor(m)

    if m>=x:
        break

    y=y+1

print(str(y))

Solution (Python):
import math
X=float(input())
T=100
i=0
while T<X:
    T=T+ math.floor(T*0.01)
    i+=1
print(i)

Solution (Python):
import math

x=int(input())
n = 0
m = 100

while m < x:
  n += 1
  m += (m // 100)

print(n)

Solution (Python):
Target = int(input())
original = 100
i=1;
while(1):
 original = original + int(original*0.01)
 if(original >= Target):
   print(i)
   break;
 i=i+1;

Solution (Python):
import math
x=int(input())
i=1
a=100
while i>0:
    a=math.floor(a*1.01)
    if a>=x:
        print(i)
        break
    else:
        i+=1

Solution (Python):
import math

x = int(input());

a = 100;
i = 0;

while a < x:
  i += 1;
  a += int(a * 0.01);
  
print(i)

Solution (Python):
import math as M
a = int(input())
n = 0

while a > 100 :
    a = M.ceil(a / 1.01)
    n += 1
print(n)

Solution (Python):
x = int(input())

a = 100

y = 0
while x > a:
    y += 1
    a = a + int(a*0.01)

print(y)

Solution (Python):
X=int(input())
sum=100
count=0
while sum<X:
    sum=int(sum*1.01)
    count+=1
print(count)

Solution (Python):
X=int(input())
i=0
n=100
while True:
  if n>=X:
    print(i)
    break
  i=i+1
  n=int(n*1.01)

Solution (Python):
import math
X=int(input())
s=100

for i in range(1,3761):
    s=math.floor(s*(1.01))
    if s>=X:
        print(i)
        break
    else:
        continue

Solution (Python):
x = int(input());
year = 0;
money = 100;

while money < x:
    v = 0.01 * money;
    r = v // 1;
    money = r + money;
    year = year + 1;

print(year);

Solution (Python):
x = int(input())
now = 100
for i in range(1,100000):
  now *= 1.01
  now //= 1
  if now >= x:
    print(i)
    break

Solution (Python):
X = int(input())

a = 100
for i in range(1, 5000):
    v = int(a * (1.01))
    if v >= X:
        break
    else:
        a = v

print(i)

Solution (Python):
X=int(input())


res=100
count=0

while True:
    res*=1.01
    res=res//1
    count+=1
    if res>=X:
        print(count)
        break

Solution (Python):
import math

X = int(input())

res = 100
count = 0
while X > res:
    res = math.floor(res * 1.01)
    count +=1

print(str(count))

Solution (Python):
X = int(input())
Gannkinn = 100
C = 0
while Gannkinn < X:
	Gannkinn += Gannkinn//100
	C += 1
print(C)

Solution (Python):
X=int(input())
Y=int(100)
t=int(0)
while Y<X:
  Y=int(Y*(1.01))
  t=t+1
print(t)

Solution (Python):
import math
X = int(input())
count = 0
res = 100

while res < X:
    count +=1
    res = math.floor(1.01*res)
print(count)

Solution (Python):
x = int(input())
a = 100
count = 0

while a < x:
    a += int(a*0.01)
    count += 1

print(count)

Solution (Python):
X = int(input())
a = 100
c = 0
while True:
    b = int(a * 1.01)
    if b >= X:
        c += 1
        print(c)
        break
    else:
        a = b
        c += 1

Solution (Python):
import math
x = int(input())
n = 16 // (math.log10(1.01))
a = 100
cnt = 0

while a < x:
    cnt += 1
    a = math.floor(a * 1.01)

'''
for i in range(1, math.floor(n)+1):
    a = math.floor(a * 1.01)
    cnt += 1
    if a >= x:
        break
    else:
        continue
'''

print(cnt)

Solution (Python):
import math
x = int(input())
a = 100
i = 0
while a < x:
  i = i + 1
  a = math.floor(a * 1.01)
print(i)

Solution (Python):
X = int(input())
        
y = 1
money = 101

while int(money) < X:
    money = int(money) * 1.01
    y += 1

print(y)

Solution (Python):
import math


x = int(input())
p = 100
y = 1
while True:
    p += math.floor(p * 0.01)
    if p >= x:
        print(y)
        exit()
    y += 1

Solution (Python):
import math


def main():
    X = int(input())

    tmp = 100
    counter = 0
    while tmp < X:
        tmp = math.floor(tmp * 1.01)
        counter += 1

    print(counter)


if __name__ == "__main__":
    main()

Solution (Python):
import math
X = float(input())
num = 100.00
count = 0
while num < X:
    num = num + math.floor(num*0.01)
    count = count + 1

print(count)

Solution (Python):
x = int(input())
const_a, count = 100, 0

while const_a < x:
  const_a += const_a//100
  count += 1
print(count)

Solution (Python):
import math






goal = int(input())
depo = 100

now_year = 0
while (True):
  depo = math.floor(depo * 1.01)
  now_year += 1
  if(depo >= goal):
    print(now_year)
    break

Solution (Python):
import math
X = int(input())
bal = 100;
y = 0
while bal < X:
    bal = math.floor(bal * 1.01)
    y += 1
print(y)

Solution (Python):
x = int(input())
start = 100
count = 0

while start < x:
    count += 1
    start = int((start*101)/100)
    
print(count)

Solution (Python):
money = 100
x = int(input())
count = 0

while money < x:
    money *= 1.01
    money = money // 1
    count +=1
print(count)

Solution (Python):
import math

X = int(input())
a = 100
num = 0

while a < X:
  a = 1.01*a
  a = math.floor(a)
  num += 1

print(num)

Solution (Python):
x = int(input())

c = 100
y = 0
while(True):
    y += 1
    c = int(c*1.01)
    if(c >= x):
        print(y)
        exit()

Solution (Python):
"""
import random
import functools
import copy
import bisect
import array
import re
import collections
import heapq
import fractions
import itertools
import string
import math
from operator import itemgetter as ig
from bisect import bisect_left, bisect_right, insort_left, insort_right
from itertools import permutations, combinations, product, accumulate, groupby
from heapq import heappush, heappop
from collections import deque, defaultdict, Counter
import sys
sys.setrecursionlimit(10 ** 7)


inf = 10 ** 20
INF = float("INF")
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = dd + [(-1, 1), (1, 1), (1, -1), (-1, -1)]
ddn9 = ddn + [(0, 0)]
'''for dx, dy in dd:
        nx = j + dx; ny = i + dy
            if 0 <= nx < w and 0 <= ny < h:'''
"""
from collections import defaultdict
import sys
import math
sys.setrecursionlimit(10 ** 7)


def wi(): return list(map(int, sys.stdin.readline().split()))



def wip(): return [int(x) - 1 for x in sys.stdin.readline().split()]


def ws(): return sys.stdin.readline().split()


def si(): return int(sys.stdin.readline())  


def ss(): return input()


def hi(n): return [si() for _ in range(n)]


def hs(n): return [ss() for _ in range(n)]  


def s_list(): return list(input())


def mi(n): return [wi() for _ in range(n)]  


def mip(n): return [wip() for _ in range(n)]


def ms(n): return [ws() for _ in range(n)]


def num_grid(n): return [[int(i) for i in sys.stdin.readline().split()[
    0]] for _ in range(n)]  


def grid(n): return [s_list() for _ in range(n)]


def gcd(a, b):
    while b:
        a, b = b, a % b
    return a




def round_up(a, b):
    """ a/b の切り上げ """
    c = (a + b - 1) / b
    return c


def lcm(a, b):
    """a,bの最小公倍数"""
    return a * b // gcd(a, b)


def main():
    x = int(input())
    a = 100
    for i in range(4000):
        a = a * 1.01
        a = int(a)
        if a >= x:
            print(i+1)
            sys.exit()


if __name__ == '__main__':
    main()

Solution (Python):
X=int(input())
Y=100
Z=0
while Y<X:
    Y=Y*1.01
    Y=int(Y)
    Z=Z+1

print(Z)

Solution (Python):
x = int(input())
i = 0
y = 100
while(y < x):
  y = int(y*1.01)
  i += 1
print(i)

Solution (Python):
X = int(input())

N = 100
C = 0

while True:
    N = int(N * 1.01)
    C += 1
    if N >= X:
        break

print(C)

Solution (Python):
if __name__ == "__main__":
    y = 0
    x = int(input())
    ans = 100

    while ans < x:
        ans *= 1.01
        ans = int(ans)
        y += 1
    print(y)

Solution (Python):
X = int(input())
b = 100
n = 0
while True:
    b += b * 0.01
    b = int(b)
    n += 1
    if b >= X:
        break
print(n)

Solution (Python):

target = int(input())
yen=100
year = 0
while yen < target:
    yen *= 1.01
    yen = int(yen)
    year += 1

print(year)

Solution (Python):

X=int(input())

money=100
cnt=0
while money < X:
	cnt=cnt+1
	money=int(money*1.01)
print(cnt)

Solution (Python):
X=int(input())
yokin=100
year=0

while yokin<X:
    yokin=int(yokin*1.01)
    year=year+1

print(year)

Solution (Python):
x = int(input().strip())
a = 100
rishi = 1.01
count = 0
while a < x:
    count += 1
    a = int(a * rishi)
print(count)

Solution (Python):
X = int(input())
a = 100
cnt = 0
while a < X :
    a = 1.01*int(a )
    cnt += 1
print(cnt)

Solution (Python):
x = int(input())
now = 100
cnt = 0
while now < x:
    cnt += 1
    now = int(now + now * 0.01)

print(cnt)

Solution (Python):

import sys
import math
import itertools

def solve(X):
    ans = 100
    i = 0
    while ans < X:
        i += 1
        ans = (math.floor(ans * 1.01))
        
    return i




def main():
    X = int(input())
    
    print(solve(X))
if __name__ == '__main__':
   main()

Solution (Python):
import math
X=int(input())
total=100
count=0
while X>total:
    total = math.floor(total*1.01)
    count +=1
print(math.ceil(count))

Solution (Python):
import math
K=int(input())

amount = 100
year = 0
while amount<K:
  amount*=1.01
  amount//=1
  year+=1

print(year)

Solution (Python):
import math
x = int(input())
s=[]
a=100
while math.floor(a*1.01)<x:
  a = math.floor(a*1.01)
  s.append(a)

print(len(s)+1)

Solution (Python):
import math

X = int(input())
a = 100

for i in range(1,10000):
    a += math.floor(a * 0.01)
    if a >= X:
        ans = i
        break
print(i)

Solution (Python):
count = 0
derm = 100
target = int(input())
while(derm < target):
    inter = derm / 100;
    derm += int(inter)
    count +=1
print(count)

Solution (Python):
X = int(input())

n = 0
Xn = 100

while Xn < X:
    n = n+1
    Xn = Xn + int(Xn*0.01)

print(n)

Solution (Python):
x = int(input())
import math
ans = 0
n = 100
for i in range(1000000):
    n=math.floor(n * 1.01)
    ans += 1
    if x <= n :
        print(ans)
        exit()

Solution (Python):
import math

X = int(input())

i = 100
count = 0

while(X > i):
    i = math.floor(i) * 1.01
    count+=1

print(count)

Solution (Python):
import math

target = int(input())
 
year = 0
money = 100
while money < target:
  year += 1
  money *= 1.01
  money = math.floor(money)
print(year)

Solution (Python):
import math
x = int(input())


q = 100
i = 0

while q < x:
    q = math.floor (q * 1.01)
    i += 1


print(i)

Solution (Python):
x = int(input())

num = 100
count = 0
while x > num:
  num = num + (num // 100)
  count += 1

print(count)

Solution (Python):
n = int(input())
res = 100
a = 0

while res < n:
  res = int(res * 1.01)
  a += 1
print(a)

Solution (Python):
import math
X = int(input())

N = 100
n = 1
while N < X :
    N = math.floor(N*1.01)
    if N<X :
        n = n + 1


print(str(n))

Solution (Python):
import math

x = int(input())
money = 100
time = 0

while(money < x):
    money = math.floor(money * 1.01)
    time += 1

print(time)

Solution (Python):
X=int(input())
N=100
i=0
while X>N:
    N=int(N*1.01)
    i+=1
print(i)

Solution (Python):
X = int(input())

n = 0
y = 100
while y < X:
    y += int(y * 0.01)
    n += 1

print(n)

Solution (Python):
import math
def intpow(X):
    return int(X*1.01)

X = int(input())

ans = math.ceil((math.log(X)-2*math.log(10))/math.log(1.01))


Xn = 100
for i in range(ans):
    Xn = int(Xn*1.01)
    

while X > Xn:
    Xn = int(Xn*1.01)
    ans += 1

print(ans)

Solution (Python):
X=int(input())
money=100
ans=0
while money<X:
    money=int(money*1.01)
    ans+=1

print(ans)

Solution (Python):
import math
X = int(input())
year = 0
s = 100
while True:
    s = math.floor(s * (1 + 0.01))
    year += 1
    if s >= X:
        print(year)
        break

Solution (Python):


X=int(input())

num=100
count=0
while num<X:
    num=num+(0.01*num)//1
    count+=1
    
print(count)

Solution (Python):
import math
n=int(input())

p=100
r=0
while p<n:
    p+=int(p*0.01)
    r+=1

print(r)

Solution (Python):
x = int(input())
amount = 100
i = 0
while amount < x:
    amount = int(amount * 1.01)
    i += 1
print(i)

Solution (Python):
import math

X=int(input())
yen=100
ans=0
while yen<X:
	yen+=math.floor(yen*0.01)
	ans+=1
	
print(ans)

Solution (Python):
m = 100
quota = int(input())
cnt = 0
while(True):
    if m >= quota:
        print(cnt)
        exit()
    m = int(m*1.01)
    cnt += 1

Solution (Python):
x = int(input())
m=100
i=0
while True:
    i += 1
    m = int(m*1.01)
    if m>=x:
        print(i)
        break

Solution (Python):
x = int(input())
m = 100
count = 0
while x > m:
    r = int(m*0.01)
    m = m + r
    count += 1
print(count)

Solution (Python):
k=int(input())
start=100
i=0
while True:
    i+=1
    start=start*1.01
    if start>k:
        break
    start=int(start)
print(i)

Solution (Python):
import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0

n = int(readline())
m = 100
ans = 0

while m < n:
    m += int(m*0.01)
    ans += 1
print(ans)