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())
cur = 100
count = 0
while cur < x:
    cur = cur*101//100
    count += 1
print(count)

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
cnt = 0
while a<x:
    a += int(a*0.01)
    cnt += 1
print(cnt)

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 7)

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines


import math


X = int(input())
ans = 0
t = 100.0

while t < X:
    t = math.floor(t * 1.01)
    ans += 1

print(ans)

Solution (Python):
import math
X = int(input())
temp = 100
for i in range(10 ** 6):
    temp = int(temp * 1.01)
    if temp >= X:
        print(i + 1)
        break

Solution (Python):

N = int(input())

ans = 100
count = 0
while(ans < N):
  ans = ans + int(ans/100)
  count = count + 1
  
  
print(count)

Solution (Python):
import math

X = int(input())

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

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

Solution (Python):
import sys
import heapq
import re
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from math import factorial, sqrt, ceil, gcd
from functools import lru_cache, reduce
INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)


class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())


def dijkstra_heap(s, edge, n):
    
    d = [10**20] * n
    used = [True] * n 
    d[s] = 0
    used[s] = False
    edgelist = []
    for a,b in edge[s]:
        heapq.heappush(edgelist,a*(10**6)+b)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        
        if not used[minedge%(10**6)]:
            continue
        v = minedge%(10**6)
        d[v] = minedge//(10**6)
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
    return d


def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr


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


def lcm_list(numbers):
    return reduce(lcm, numbers, 1)


def gcd_list(numbers):
    return reduce(gcd, numbers)


def is_prime(n):
    if n <= 1:
        return False
    p = 2
    while True:
        if p ** 2 > n:
            break
        if n % p == 0:
            return False
        p += 1
    return True



def eratosthenes(limit):
    A = [i for i in range(2, limit+1)]
    P = []

    while True:
        prime = min(A)
        
        if prime > sqrt(limit):
            break
            
        P.append(prime)
            
        i = 0
        while i < len(A):
            if A[i] % prime == 0:
                A.pop(i)
                continue
            i += 1
            
    for a in A:
        P.append(a)
            
    return P


def permutation_with_duplicates(L):

    if L == []:
        return [[]]

    else:
        ret = []

        
        S = sorted(set(L))

        for i in S:

            data = L[:]
            data.remove(i)

            for j in permutation_with_duplicates(data):
                ret.append([i] + j)

        return ret



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

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

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

y = 1
s = 100
while s<x:
    s = int(s*1.01)
    y += 1
print(y-1)

Solution (Python):
x = int(input().strip())
a = 100
ans = 0
while True:
    a *= 1.01
    a = int(a)
    ans += 1
    if x <= a:
        print(ans)
        exit()

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

p = 100
res = 0

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

print(res)

Solution (Python):
import sys
x=int(input())
a=100
for i in range(10**6):
  a=int(a*1.01)
  if a>=x:
    print(i+1)
    sys.exit()

Solution (Python):
x=int(input())
a=100
cnt=0
while x>a:
    cnt+=1
    a=a*1.01//1
print(cnt)

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

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

    m = 100

    k = 0
    while m < X:
        k += 1
        m += m // 100
    print(k)


if __name__ == '__main__':
    main()

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

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


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

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


if __name__ == "__main__":
    main()

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

Solution (Python):
import math
def I():
  return input()
def II():
  return int(input())
def MII():
  return map(int, input().split())
def LMII():
  return list(map(int, input().split()))

n = II()
x = 0
m = 100
while m < n:
  m = m*101//100
  x += 1
  
print(x)

Solution (Python):


def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate, groupby, product
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    import math
    from math import gcd

    
    

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

if __name__ == '__main__':
    main()

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

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

Solution (Python):
def main():
    X = int( input())
    now = 100
    for i in range(100000):
        now = now*101//100
        if now >= X:
            print(i+1)
            return
if __name__ == '__main__':
    main()

Solution (Python):
X = int(input())
ans = 0
money = 100

while money < X:
    money = money + int(money * 0.01)
    ans += 1

print(ans)

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

Solution (Python):
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]




import math
N = ii()
a = 100
n = 0
while True:
    a = math.floor(a * 1.01)
    n += 1
    if a >= N:
        print(n)
        exit()

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

prev = 100
days = 0
while prev < a:
	add = (prev * 1) // 100
	prev += add
	days += 1

print(days)

Solution (Python):
import math

X = int(input())
y = 0
m = 100
while m < X:
    m = math.floor(m * 1.01)
    y += 1
print(y)

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

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

from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
from collections import deque, defaultdict
from itertools import combinations, permutations
from itertools import accumulate
from math import ceil, sqrt, pi

MOD = 10 ** 9 + 7
INF = 10 ** 18

X = int(input())

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

Solution (Python):






import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache

import heapq






MOD = 10**9+7
INF = float('inf')






def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]


def inv(n): return pow(n, MOD-2, MOD)


kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret


def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr


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





X = inputI()

a = 100
count = 0

while a<X:
  a = int(a*1.01)
  count += 1
    
print(count)

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


main()

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

print(i)

Solution (Python):
x=int(input())
tmp=100
for i in range(10000):
  if tmp>=x:
    print(i)
    break
  tmp+=tmp//100

Solution (Python):
import sys


sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7


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


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

    print(cnt)


if __name__ == "__main__":
    main()

Solution (Python):


import math
x = int(input())
cnt = 100
nen = 0
while cnt < x:
	cnt = (cnt * 101) //100
	nen += 1
print(nen)

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

if __name__ == "__main__":
    main()

Solution (Python):

import sys
import math

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


if __name__ == '__main__':
    main()

Solution (Python):


import sys
sys.setrecursionlimit(300000)


def solve(X: int):
    ret = 0
    i = 100
    while i < X:
        i = int(i * 1.01)
        ret += 1
    print(ret)
    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):
def main():
    import sys
    sys.setrecursionlimit(10 ** 6)
    input = sys.stdin.readline
    X = int(input())
    Y = 100
    i = 0
    while Y < X:
        i += 1
        Y = int(Y * 1.01)
    print(i)
if __name__ == '__main__':
    main()

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

Solution (Python):
x = int(input())
tmp = 100
for i in range(1, 10 ** 5):
    tmp = int(tmp * 1.01)
    if tmp >= x:
        print(i)
        break

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

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

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

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

s = 100
c = 0

while s < x:
    s += s // 100
    c += 1

print(c)

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

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

t=100
cnt=0
while t<X:
    t+=int(t*0.01)
    cnt+=1
print(cnt)

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


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

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

    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):

import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1

def main():
    X=int(input())
    z=100
    for i in range(1,10000):
        z=int(z*1.01)
        if z>=X:
            print(i)
            exit()
    

if __name__ == '__main__':
    main()

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

X = INT()

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

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

if __name__ == '__main__':
    main()

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

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

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

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

print(ans)

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

tmp = 100
count = 0
while tmp < X:
    tmp = (tmp * 101) // 100
    count += 1

print (count)

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

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

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

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

Solution (Python):
x = int(input())
tmp = 100
count = 0
for i in range(3800):
         tmp = int(tmp * 1.01)
         count += 1
         if tmp >= x:
                  print(count)
                  exit()

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

Solution (Python):
X = int(input())
ans = 0
Y = 100
while Y<X:
  Y = Y*101//100
  ans += 1
print(ans)

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

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

Solution (Python):
from math import *
x = int(input())
a = 0
cur = 100
while cur < x:
	cur = int(cur * 1.01 + 10**-7)
	a+=1
print(a)

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

Solution (Python):
x = int(input())
yokin = 100
ans = 1

while True:
    yokin = yokin * 1.01 // 1

    if yokin >= x:
        break

    ans = ans + 1

print(ans)

Solution (Python):
import math

X = int(input())
a = 100
n = 0
while True:
    n += 1
    a = math.floor(a * 1.01)
    if a >= X:
        print(n)
        exit()

Solution (Python):
import sys, bisect, math, itertools, string, queue, copy


from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush
from fractions import gcd

sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

def main():
    n = 100
    x = inp()
    ans = 0
    while n < x:
        n *= 1.01
        n = int(n)
        ans += 1
    print(ans)
    
if __name__ == "__main__":
    main()

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

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

print(i)

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

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

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

print(ans)

Solution (Python):

X = int(input())

cnt = 0
now = 100

while now < X:

    now = int( now * 1.01 )
    cnt += 1

print (cnt)

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

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

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

Solution (Python):
def examA():
    K = I()
    A, B = LI()
    for i in range(A,B+1):
        if i%K==0:
            print("OK")
            return
    print("NG")
    return

def examB():
    X = I()
    now = 100
    ans = 0
    while(now<X):
        ans += 1
        now += now//100
    print(ans)
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    ans = 0
    print(ans)
    return

def examF():
    ans = 0
    print(ans)
    return

import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(readline())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]

sys.setrecursionlimit(10**7)

if __name__ == '__main__':
    examB()

"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
"""

Solution (Python):
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections

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

Solution (Python):
import sys

def solve():
    input = sys.stdin.readline
    X = int(input())
    now = 100
    for i in range(1, 10 ** 18):
        now = int(now * 1.01)
        if now >= X:
            print(i)
            break

    return 0

if __name__ == "__main__":
    solve()

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

Solution (Python):
import sys
input=lambda: sys.stdin.readline().rstrip()
x=int(input())
t=1
cur=100
while cur<x:
  cur=int(cur*1.01)
  if cur>=x:
    print(t)
    break
  else:
    t+=1

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

Solution (Python):
n = int(input())
now = 100
for i in range(40000):
  now = int(now*1.01)
  if now >= n:
    print(i+1)
    break

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

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

Solution (Python):

from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]
def I(): return int(sys.stdin.buffer.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
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)]

sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    x = I()
    y = 100
    for i in range(1,5000):
        y = int(y*1.01)
        if y >= x:
            print(i)
            return
    return


if __name__ == "__main__":
    solve()

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

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

ans=0
c=100
while 1:
    if c>=x:
        print(ans)
        exit()
    c += int(c*0.01)
    ans+=1

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

Solution (Python):



import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

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

while N < X:
    ans += 1
    N += N // 100

print(ans)

Solution (Python):
from sys import stdin
from sys import setrecursionlimit

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

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

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

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

now = 100
ans = 0
while True:
    ans += 1
    now = now * 1.01 // 1
    if now >= x:
        print(ans)
        exit()

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

Solution (Python):

import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial
from bisect import bisect_left 
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
def pri(x): print('\n'.join(map(str, x)))

X = int(input())
v = 100

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


print(cnt)

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

year = 0
m = 100
while True:
    if m >= x:
        break
    m = m*1.01
    m = m//1
    year += 1

print(year)

Solution (Python):
def Int():
    return int(input())
def Ints():
    return map(int,input().split())
def IntList():
    return list(Ints())
def IntMat(N):
    return [IntList() for i in range(N)]

now = 100
ans = 0
X = Int()

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

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

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

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

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

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

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  x=I()
  a=100

  ans=1
  while True:
    a*=1.01
    a=int(a)
    if a>=x:
      return ans
    ans+=1


print(main())

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

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

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

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

print(j)

Solution (Python):
X=int(input())
NOW=100
for i in range(10**7):
    if NOW>=X:
        print(i)
        break
    NOW=NOW*101//100

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

s = 100
for i in range(10000):
    s = int(s*1.01)
    if s>=x:
        print(i+1)
        exit()

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

print(ans)

Solution (Python):
from sys import stdin
from sys import setrecursionlimit
from collections import Counter, deque, defaultdict
from math import floor
from bisect import bisect_left
setrecursionlimit(1000000)

INF = int(1e10)
MOD = int(1e9 + 7)

def input():
    return stdin.readline()[:-1]


def main():
    from builtins import int, map
    X = int(input())
    now = 100

    count = 0
    while now < X:
        count += 1
        now = floor(now * 1.01)

    print(count)


if __name__ == '__main__':
    main()

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

now = 100
cnt = 0
while True:
    now = int(now * 1.01)
    cnt += 1
    if x <= now:
        print(cnt)
        exit()

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

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

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

c = 100
for i in range(1, 10**8):
    c = int(c * 1.01)
    if c >= X:
        print(i)
        exit()

Solution (Python):
import sys
sys.setrecursionlimit(1000000)

def solve(X):
    k = 100
    ans = 0
    while k < X:
        k = k + int(k * 0.01)
        ans += 1
    return ans

if __name__ == "__main__":
    X = int(input())
    print(solve(X))

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

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

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

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

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

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

    a = 100
    ans = 0
    while a < x:
        a = (a * 101) // 100;
        ans += 1

    print(ans)

if __name__ == '__main__':
    main()

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

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

Solution (Python):
import sys
readline = sys.stdin.readline
import math

def main():
    X = int(readline())
    ans = 100
    cnt = 0
    while ans < X:
        ans += math.floor(ans * 0.01)
        cnt += 1
    print(cnt)

if __name__ == '__main__':
    main()

Solution (Python):
X = int(input())
c = 100
for i in range(10**8):
    c += c // 100
    if c >= X:
        print(i+1)
        break

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7 
input=lambda:sys.stdin.readline().rstrip()
def resolve():
    x = int(input())
    now = 100
    cnt = 0
    while now < x:
        now = now * 101 // 100
        cnt += 1
    print(cnt)
resolve()