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())
p=100
i=0
import math
while True:
    p*=1.01
    p=math.floor(p)
    if p>=x:
        print(i+1)
        break
    i+=1

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

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

balance = 100
cnt = 0
while True:
    if balance >= x:
        print(cnt)
        break
    cnt += 1
    balance = int(balance*1.01)

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

money = 100
for i in range(4000):
    if money >= X:
        print(i)
        break
    money = (money * 101) // 100

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

money = 100
year = 0

while True:
    money = int(money * 1.01)
    year += 1
    if money >= x:
        break

print(year)

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

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

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

Solution (Python):
x=int(input())
count=0
now=100
while True:
    if now>=x:
        print(count)
        exit()
    now+=int(now*(0.01))
    count+=1

Solution (Python):
import sys
import math
import collections
from collections import deque
from functools import reduce
import heapq
x = int(input())




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

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

ans = 0
tmp = 100

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

print(ans)

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

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

Solution (Python):
def resolve():
    x = int(input())
    n = 100
    for i in range(1, 1000000):
        n = int(n * 1.01)
        if n >= x:
            print(i)
            return


if __name__ == '__main__':
    resolve()

Solution (Python):
x=int(input())
a=100
b=0
while a < x:
  a*=101
  a//=100
  b+=1
print(b)

Solution (Python):
MOD = 10 ** 9 + 7
INF = 10 ** 11
import sys
sys.setrecursionlimit(100000000)

def main():
    x = int(input())
    a = 100
    cnt = 0
    while a < x:
        a = a*101//100
        cnt += 1
    print(cnt)
if __name__ == '__main__':
    main()

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

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

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

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

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

okane = 100

cnt = 0
while True:
  if int(okane) >= X:
    print(cnt)
    sys.exit()
  okane = okane + int(okane * 0.01)
  cnt += 1

Solution (Python):
X = int(input())
yen = 100
for i in range(1, 4000):
    yen *= 1.01
    yen = yen // 1
    if yen >= X:
        print(i)
        exit()

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

Solution (Python):
import math
c = 100
x = int(input())
ans = 0
while(True):
    ans += 1
    c = c*1.01
    c = math.floor(c)
    if x <= c:
        break
print(ans)

Solution (Python):


x=int(input())

a=100
ans=0
while a<x:
    a*=1.01
    a//=1
    
    ans+=1

print(ans)

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

Solution (Python):
x = int(input())
sub = 1
now_ch = 100
while True:
    now_ch = now_ch*1.01//1
    if now_ch >= x:
        print(sub)
        break
    else:
        sub+=1

Solution (Python):

import bisect
import heapq
import itertools
import math
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from math import gcd
from operator import add, itemgetter, mul, xor
def cmb(n,r,mod):
  bunshi=1
  bunbo=1
  for i in range(r):
    bunbo = bunbo*(i+1)%mod
    bunshi = bunshi*(n-i)%mod
  return (bunshi*pow(bunbo,mod-2,mod))%mod
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def I(): return int(input())
def LI(): return list(map(int,input().split()))
def MI(): return map(int,input().split())
def LLI(n): return  [list(map(int, input().split())) for _ in range(n)]

x = I()
m = 100
ans = 0
while m < x:
    m = (m*0.01)//1 + m
    ans += 1
print(ans)

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

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

Solution (Python):
def main():
    x = int(input())
    
    a = 100
    n = 0

    while True:
        n+=1
        a *=101
        a //= 100
        if a>=x:
            print(n)
            break
if __name__ == "__main__":
    main()

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

from math import floor

x = int(readline())
v = 100
for i in range(x):
    v = floor(v * 1.01)
    if v >= x:
        print(i + 1)
        exit()

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

Solution (Python):
import numpy as np
import sys
import math
read = sys.stdin.readline

x = int(input())
cash = 100
year = 0
while True:
    year += 1
    cash = int(cash * 1.01)
    if cash >= x:
        print(year)
        break

Solution (Python):
from math import floor
X = int(input())
n = 100
for i in range(10**4):
    n = floor(n*1.01)
    if n >= X:
        print(i+1)
        exit()

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

print(i)

Solution (Python):
















X = int(input())

num = 100
ans = 0
while num<X:
    num = num*101//100
    ans += 1
print(ans)

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

start = 100.0
year = 0
while start < x:
    start = (start * 1.01) // 1
    year += 1

print(year)

Solution (Python):
import sys
sys.setrecursionlimit(10**6)
from math import floor,ceil,sqrt,factorial,log
from heapq import heappop, heappush, heappushpop,heapify
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
mod = 10 ** 9 + 7
inf = float('inf')
ninf = -float('inf')
 

def ii(): return int(sys.stdin.readline().rstrip()) 
def mii(): return map(int,sys.stdin.readline().rstrip().split())
def limii(): return list(mii()) 
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]

def ss(): return sys.stdin.readline().rstrip() 
def mss(): return sys.stdin.readline().rstrip().split()
def limss(): return list(mss()) 
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]






x=ii()
a=100
cnt=0
while a<x:
    a=a+a*0.01
    a=int(a)
    cnt+=1
    
print(cnt)

Solution (Python):




import sys
input = sys.stdin.readline



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

    now = 100
    res = 0

    while True:
        res += 1
        now *= 1.01
        now = int(now)
        if now >= X:
            break

    print(res)



main()

Solution (Python):
x = int(input())
m = 100
i = 0
while m<x:
  m += int(m/100)
  i += 1
print(i)

Solution (Python):
import math
x = int(input())
a = 100
cnt = 0
while True:
    a += math.floor(a*0.01)
    cnt += 1
    if a >= x:
        print(cnt)
        exit()

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

Solution (Python):
import sys
import itertools
if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
    
money=100
cnt=0
x=int(input())
while money<x:
	money=int(money*1.01)
	cnt+=1
	
print(cnt)

Solution (Python):
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def resolve():
    X = ir()
    tmp = 100
    ans = 0
    while tmp < X:
        tmp = int(tmp*1.01)
        ans += 1
    print(ans)
resolve()

Solution (Python):
import math

N = int(input())

OKANE = 100
counter = 0

while OKANE < N:
    OKANE = math.floor(OKANE * 1.01)
    counter += 1
    
    
print(counter)

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

start = 100
year = 0

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

print(year)

Solution (Python):
k = int(input())
count = 0
nach = 100
while k > nach:
    nach *= 101
    nach //= 100
    count += 1
print(count)

Solution (Python):
def LI():return list(map(int,input().split()))




x=int(input())
m=100
for i in range(5000):
    m=int(m*1.01)
    if m>=x:
        print(i+1)
        exit()

Solution (Python):
x  = int(input())
amount = 100
cnt = 0

while amount < x:
  amount = int(amount * 1.01) 
  cnt += 1

print(cnt)

Solution (Python):


import sys

DEBUG = False

def read(t):
    return t(sys.stdin.readline().rstrip())


def read_list(t, sep = " "):
    return [t(s) for s in sys.stdin.readline().rstrip().split(sep)]


def dprint(*args, **kwargs):
    if DEBUG:
        print(*args, **kwargs)
    return


def main():
    x = read(int)

    m = 100
    i = 0
    while m < x:
        m = int(m * 1.01)
        i += 1
    print(i)


if __name__ == "__main__":
    main()

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


print(ans)

Solution (Python):


from queue import Queue
from queue import LifoQueue as Stack
from math import sqrt, floor, ceil, log2, log10, pi
from fractions import gcd
from itertools import permutations, combinations
from operator import itemgetter
from functools import cmp_to_key


INF=1001001001
__MOD__=(10**9)+7
yn = 'YNeos'
judge = False
cnt = 0
ans = None


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

def intinput():
    return int(input())

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

def lineinputs(func=intinput):
    datas = []
    while True:
        try:
            datas.append(func())
        except EOFError:
            break
    return datas

class ModInt():
    def __init__(self, x):
        self.__x = (x % __MOD__)
    def __add__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x + other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x + other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __radd__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x + self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x + self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __sub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x - other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x - other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rsub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x - self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x - self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __mul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rmul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x * self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x * self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __truediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rtruediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x * self.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x * self.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __pow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(self.__x, other.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(self.__x, other.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")
    def __rpow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(other.__x, self.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(other.__x, self.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")

    def __modinv(self, m=__MOD__):
        a = self.__x
        if a == 0:
            raise ZeroDivisionError()
        if gcd(a, m) != 1:
            raise Exception("%sの逆数は求まりません。" % a)
        b, u, v = m, 1, 0
        while b != 0:
            t = a//b;
            a -= t*b
            a, b = b, a
            u -= t * v
            u, v = v, u
        u %= m
        if u < 0:
            u += m
        return u
    def __int__(self):
        return self.__x
    def __str__(self):
        return str(self.__x)



if __name__ == '__main__':
    X = intinput()

    yokin, i = 100, 1
    
    while True:
        yokin = int(yokin * 1.01)
        if yokin >= X:
            break
        i += 1
    
    print(i)

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

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

m = 100
cnt = 0
while m < X:
    m = (m*1.01)//1
    cnt += 1
print(cnt)

Solution (Python):
import math

x = int(input())

i = 0
n = 100

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

Solution (Python):

x = int(input())
p = 100
for i in range(1, 10000):
    p = int(p * 1.01)
    if p >= x:
        print(i)
        exit()

Solution (Python):
X = int(input())
a, tmp = 100, 0

while True:
    tmp += 1
    a += a // 100
    if a >= X:
        print(tmp)
        break

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

print(ans)

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

print(count)

Solution (Python):
def main():
    X = int(input())
    now = 100
    year = 0
    while now < X:
        add = now//100
        now += add
        year += 1
    print(year)
    return
main()

Solution (Python):
X = int(input())
yokin = 100
ans = 0
while ans >= 0:
  yokin = int(yokin * 1.01)
  ans += 1
  if yokin >= X:
    break
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())
m = 100

counter = 0
while (m < X):
    m = int(m * 1.01)
    counter += 1
print(counter)

Solution (Python):
x = int(input())
money = 100
count = 0
while money < x:
    money += int(money*0.01)
    count += 1
print(count)

Solution (Python):
from math import log, ceil

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

Solution (Python):
import math

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

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

print(ans)

Solution (Python):











import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,sqrt,factorial,hypot,log 
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from fractions import gcd
from random import randint
def ceil(a,b): return (a+b-1)//b
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    X=I()
    N=100
    ans=0
    while(X>N):
        N+=N//100
        ans+=1
    print(ans)
if __name__ == '__main__':
    main()

Solution (Python):

import sys


def solve(X: int):
    ct = 0
    yo = 100
    while yo < X:
        yo *= 1.01
        yo = int(yo)
        ct += 1
    print(ct)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    X = int(next(tokens))  
    solve(X)

if __name__ == '__main__':
    main()

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

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

Solution (Python):
import math

x = int(input())
m = 100
count=0
while m<x:
  m = m*1.01//1
  count+=1
print(count)

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

print(ans)

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

m = 100
for i in range(10**18) :
    if m >= x :
        print(i)
        break
    m = int(m*1.01)

Solution (Python):
import sys
import math
from collections import Counter
import itertools
import fractions



def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())

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

def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SR(): return sys.stdin.readline().rstrip()

ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_uppercase2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'


p2D = lambda x: print(*x, sep="\n")
p2E = lambda x: print(''.join(x))
p2S = lambda x: print(*x, sep=" ")


 
X=II()
ans=0
x=100
while True:
    ans+=1
    x=int(x*1.01)
    if x >= X:
        print(ans)
        exit()

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

Solution (Python):
x = int(input())
y = 100
n = 0
while y < x:
  y = (101 * y) // 100
  n += 1
print(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


input = sys.stdin.buffer.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(X):
    T = 100
    for i in range(INF):
        T *= 1.01
        T = int(T)
        if X <= T:
            return i + 1


def main():
    X = read_int()
    print(slv(X))


if __name__ == '__main__':
    main()

Solution (Python):
x = int(input())
p = 100
for i in range(1000000):
    p += int(p/100)
    if x <= p:
        print(i+1)
        break

Solution (Python):
I = int(input())
current = 100
num = 0

while(current < I):
    current = int(current + current*0.01)
    num += 1


print(num)

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

K = 100
cnt = 0
while(K<X):
    K *= 1.01
    K = K//1
    cnt += 1
    
print(cnt)

Solution (Python):
X = int(input())
year = 0
money = 100
while True:
    year += 1
    money += int(money / 100)
    if money >= X:
        break
print(year)

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

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

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

for i in range(1,4000):
    mo=mo*1.01
    mo=mo//1
    if (mo>=x):
        print(i)
        break

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

Solution (Python):
import math

X = int(input())

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

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

yen = 100
year = 0
while yen < X:
    yen = int(1.01*yen)
    year += 1
print(year)

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

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

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

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

print(count)

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

Solution (Python):

MOD = 10 ** 9 + 7
INFI = 10**10

import math

import itertools
import heapq


import copy
from functools import lru_cache

def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default




def ret(a):
    c=[None]*(len(a)-1)
    if len(a)==1:
        return a[0]
    elif len(a)==0:
        return 0
    for i in range(1,len(a)):
        c[i-1]=abs(a[i]-a[i-1])
    return ret(c)


def main():
    x=int(input())
    y=0
    yen=100
    while True:
        temp=yen//100
        yen+=temp
        y+=1
        if yen>=x:
            break
    print(y)



if __name__ == "__main__":

    main()

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

Solution (Python):
mod = 10**9+7
import sys
from collections import Counter, defaultdict, deque
from itertools import product, permutations, combinations
from itertools import accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush
from math import ceil,floor
from copy import deepcopy
from heapq import heappop,heappush,heapify
import heapq







sys.setrecursionlimit(10 ** 6)

int1 = lambda x: int(x) - 1


p2D = lambda x: print(*x, sep="\n")

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

def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())




def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LI(): return list(map(lambda x:int(x), sys.stdin.readline().split()))
def HI(): return list(map(lambda x:int(x)*(-1), sys.stdin.readline().split()))



x = II()
m = 100
i = 0
while(1):
	if m >= x:
		break
	m *= 1.01
	m = int(m)
	i += 1
print(i)

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

dyear = 0
price = 100

while price < X:
    dyear += 1
    price = int(price * 1.01)
print(dyear)

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

x=100
n=0
while True:
  t=int(x*0.01)
  x+=t
  n+= 1
  if x >= goal:
    break

print(n)

Solution (Python):
def main():
    m = 100
    x = int(input())
    y = 0
    while True:
        m = m + int(m * 0.01)
        y += 1
        if x <= m:
            break
    print(y)


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


if __name__ == '__main__':
    main()

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

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

azuke = 100
ans = 0
while True:
    azuke = int(azuke*1.01)

    ans += 1
    if azuke >= X:
        print(ans)
        exit(0)

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

ans=0
tmp=100
while(1):
    if tmp>=X:
        break
    tmp=tmp+tmp//100
    ans+=1
print(ans)

Solution (Python):
from sys import stdin
import math

if __name__ == "__main__":
    _in = [_.rstrip() for _ in stdin.readlines()]
    X = int(_in[0])  
    
    yen = 100
    cnt = 0
    while (yen<X):
        yen = math.floor(yen*1.01)
        cnt += 1
    
    print(cnt)

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

Solution (Python):
x=int(input())
n=100
k=0
while n<x:
  n=n*101//100
  k+=1
print(k)

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

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

money = 100
year = 0
while 1:
  money = int(money * 1.01)
  year += 1
  if money >= X:
    break
    
print(year)

Solution (Python):
x=int(input())
n=100.0
c=0
while(n<x):
  n+=int(0.01*n)
  c+=1
print(c)

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

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

for y in range(10000):
    if m >=X:
        print(y)
        break
    m = int(m*1.01)

Solution (Python):
import sys

x = int(input())

year = 0

depos = 100

while depos<x:
    temp = depos*1.01
    depos = int(temp)
    year+=1

print(year)

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

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

years = 0
money = 100
while(True) :
    years += 1
    money += int(money * 0.01)
    if (X <= money) :
        break

print(years)

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

m=100

i=0
while(1):
  m=int(m*1.01)
  i+=1
  if m>=x:
    print(i)
    break

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

tmp = 100
for i in range(10 ** 20):
    if tmp >= x:
        print(i)
        exit()
    tmp = int(tmp * 1.01)

Solution (Python):
from math import gcd

from math import factorial as f

from math import ceil,floor,sqrt


import bisect
import re
import heapq


from copy import deepcopy
import itertools

from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

yes = "Yes"
no = "No"

def main():
    x = ii()
    cnt = 0
    tmp = 100
    while tmp<x:
        tmp+=tmp//100
        cnt+=1
    print(cnt)




main()

Solution (Python):
def solve():
    X = int(input())
    now = 100
    year = 0
    while now < X:
        now = now + now // 100
        year += 1
    print(year)

    
if __name__ == '__main__':
    solve()

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

Solution (Python):


X = int(input())

now = 100
ans = 0
while now < X:
    now = int(now * 1.01)
    ans += 1

print(ans)

Solution (Python):
X = int(input())
import math
ans = 0
y = 100

while True:
  y *= 1.01
  y = math.floor(y)
  ans+=1
  if y>=X:
    break
    
print(ans)

Solution (Python):
from statistics import median


from fractions import gcd
from itertools import combinations 
from collections import deque
from collections import defaultdict
import bisect










import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7

def readInts():
  return list(map(int,input().split()))
def main():
    X = int(input())
    m = 100
    cnt = 0
    while True:
        
        if m >= X:

            print(cnt)
            exit()
        else:
            m = int(m * 1.01)
            cnt += 1

if __name__ == '__main__':
  main()

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

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

Solution (Python):
x=int(input())
money=100
cnt=0
while money<x:
    money+=money//100
    cnt+=1
print(cnt)

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