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):
import math
N = int(input())
yokin = 100
n = 0
while yokin < N:
    yokin = math.floor(yokin*1.01)
    n = n +1
print(n)

Solution (Python):
from math import floor
x = int(input())
y = 100
i = 0
while True:
    i += 1
    risoku = floor(y*(1/100))
    y = y+risoku

    if y >= x:
        print (i)
        exit ()

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

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

for i in range(1, 10**10):
    cur = int(cur * 1.01)
    if cur >= x:
        print(i)
        exit()

Solution (Python):
import math


X = int(input())
d = 100
i = 0

while (True):
    i += 1
    d = math.floor(d * (1.01))
    if d>= X:
        break

print (i)

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

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

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

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

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

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

a = 100
count = 0
while a < x:
    a *= 1.01
    a = int(a)
    count += 1

print(count)

Solution (Python):
import math

x = int(input())

money = 100
count = 0

while money <= x :
    money = math.floor(money * 1.01)
    
    count = count + 1
    
    if money == x :
        break

print(count)

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

Solution (Python):
import math
num = int(input())
a = 100
count = 0 

while a < num:
    a = a + a*0.01
    a = math.floor(a)
    count = count + 1
print(count)

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

Y=100
for i in range(1,10**18):
    Y=int(Y*1.01)
    if Y>=X:
        print (i)
        break

Solution (Python):
X = int(input())
f=0
c=0
y=100
if y<X:
  while f==0:
    c+=1
    y = int(float(y)*1.01)
    if y>=X:
      f=1
  print(c)
else:
  print(0)

Solution (Python):

x=int(input())
a=100
b=100
for i in range(1,100001):
  a*=1.01
  a-=100
  a=int(a)
  a+=b
  
  if a>=x:
    print(i)
    exit(0)

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

def main():
    X = int(read())
    yokin = 100
    ans = 0
    while yokin < X:
        yokin = int(yokin * 1.01)
        ans += 1
    print(ans)
    return

if __name__ == '__main__':
    main()

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

money = 100
count = 0

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

print(count)

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

Solution (Python):
n = int(input())
initial_amount = 100
year = 0 
while(initial_amount<n):
    initial_amount += (initial_amount*1)//100
    year+=1

print(year)

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

count = 0
money = 100

while x > money:
    money = math.floor(money*1.01)
    count += 1

print(count)

Solution (Python):
def main():
    x = int(input())
    d = 100
    y = 1

    while True:
        d = int(d * 1.01)
        if(d>=x):
            print(y)
            break
        y += 1
main()

Solution (Python):
import sys
from math import log 

def solve(X: int):

    n = 100
    k = 0

    while n < X:
       n = int(n * 1.01)
       k += 1

    print(k)

    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):
money = (int)(input())
takahashi = 100
year = 0
while(takahashi < money):
    year += 1
    takahashi = (int)(takahashi * 1.01)
print(year)

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

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

print(year)

Solution (Python):
import math

X = int(input())

INTEREST_RATE = 0.01
amount = 100

years = 0
while True:
    interest_amount = amount * INTEREST_RATE
    interest_amount = math.floor(interest_amount)

    if amount >= X: break
    amount += interest_amount
    
    years += 1

print(years)

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

    x = int(input())
    c = 100
    for i in range(1,10 ** 9):
        c = int((c * 101) // 100)
        if c >= x:
            print(i)
            break

if __name__ == "__main__":
    main()

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

Solution (Python):


ipnl = lambda n: [int(input()) for _ in range(n)]
inp = lambda :int(input())
ip = lambda :[int(w) for w in input().split()]
mp = lambda :map(int,input().split())

p = 100
x = inp()
n = 0
while p < x:
    p += int(p*0.01)
    
    n += 1
print(n)

Solution (Python):
import sys
import math as mt
import collections as cc
I=lambda:list(map(int,input().split()))
n,=I()
x=100
i=0
while x<n:
    i+=1
    temp=x*0.01
    x+=mt.floor(temp)
    
    
print(i)

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

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

Solution (Python):
X = int(input())
S = 100
for i in range(1000000000000000):
    S += int((0.01) * S)
    if S >= X:
        print(i+1)
        break

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

Solution (Python):


X = int(input())

s = 100
n = 0

while s < X:
    s *= 1.01
    s = int(s)
    n += 1
print(n)

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

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

print(i)

Solution (Python):

import sys
import math

def solve(X: int):



    N = 0
    Y = 100
    while(Y < X):
        Y = math.floor(Y * 1.01)
        N += 1
    print(N)
    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):
x = int(input())

ans = 0

value = 100

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

print(ans)

Solution (Python):
import math

x =int(input())

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

Solution (Python):
import math


def read_int():
    return int(input().strip())


def read_ints():
    return list(map(int, input().strip().split(' ')))


def solve():
    X = read_int()
    year = 0
    amount = 100
    while amount < X:
        amount = int(amount*1.01)
        year += 1
    return year


if __name__ == '__main__':
    print(solve())

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

Solution (Python):
import math

x = int(input())
y = 1 / 100
z = 1
a = 100

while True:
    a = a + math.floor(a * y)
    if a >= x:
        print(z)
        break
    z = z + 1

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()

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

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

if __name__ == '__main__':
    main()

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

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

Solution (Python):
from heapq import heappush, heappop
from itertools import permutations, accumulate, combinations
from math import pi, ceil, floor, log
import numpy as np
from collections import defaultdict, deque,Counter
from operator import itemgetter
from bisect import bisect_left, bisect_right, insort_left, insort_right
import sys
input = sys.stdin.readline





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


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
def b165(x):

    ans = 0
    manycount = 100
    for i in range(10000000):
        if manycount >= x:
            break
        else:
            ans += 1
            manycount += manycount//100

    return ans

def main():
    x = int(input())
    print(b165(x))

if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
c = 0
b = 100

while n > b:
    c += 1
    b *= 1.01
    b = int(b)

print(c)

Solution (Python):
import math
N=int(input())
A=100
for i in range(1,100001):
    si=(A*1)/100
    A=si+A
    A=math.floor(A)
    if(A>=N):
        print(i)
        break

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

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

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

while i < x:
  i = int(i*1.01)
  count += 1
  
print(count)

Solution (Python):
import math

X = int(input())
t = 100
c = 0

while X>t:
  t = math.floor(t*1.01)
  c += 1
  
print(c)

Solution (Python):
X = int(input())
money = 100
for i in range(1, X):
    money = int(money*1.01)
    if money >= X:
        break

print(i)

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

t = 100
count = 0
while True:
  if t >= x:
    print(count)
    exit()
  
  t = int(t + t*0.01)
  count += 1

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

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

print(c)

Solution (Python):
from math import floor

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

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

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

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

    print(y)



if __name__ == "__main__":
    b()

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

Solution (Python):
X = int(input())
money = 100
count = 0
while(X > money):
    money += int(str(money)[:len(str(money)) - 2])
    count += 1
print(count)

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

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

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

count = 0
balance = 100
while (True):
    balance = balance + math.floor(balance * 0.01)
    count += 1
    if balance >= X:
        break

print(count)

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

first_chokin = 100
now_chokin = first_chokin
year = 0
while(now_chokin < X):
    now_chokin = int(now_chokin * 1.01)
    year = year + 1

print(year)

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

money = 100
countYear = 0

while money < x:
    money = money * 1.01 // 1
    countYear += 1

print(countYear)

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

Solution (Python):
def main():
  x = int(input())
  val = 100
  year=1
  while True:
    val = int(val * 1.01)
    if x <= val:
      break
    year += 1

  print(year)

if __name__ == '__main__':
  main()

Solution (Python):
k = int(input())
c = 100
i = 0

while c < k:
    c  = (int)(c * 1.01)
    i += 1

print(i)

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

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

a = 1.01
m = 100
cnt = 0

while m < x:
    m = int(m) * a
    cnt += 1
print(cnt)

Solution (Python):
x = input() 
x = int(x)
chokin = 100
rishi = 0.01 
counta = 0

while True:
    if chokin >= x:
        break
    else:
        chokin += int(chokin * rishi)
        counta += 1

print(counta)

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

print(n)

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

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

money = 100

counter = 0
while True:
    counter += 1
    money = money + int(money*0.01)
    if(money >= X):
        print(counter)
        exit()

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

money = 100
for i in range(1, 4000):
    money = money*1.01
    money = int(money)
    if int(money) >= x:
        print(i)
        exit()

Solution (Python):
import math

x = int(input())
depo = 100
count = 1

while True:
    depo = math.floor(depo*1.01)
    if depo >= x:
        print(count)
        break
    count += 1

Solution (Python):
def year(x) :
    return int(float(x)*1.01)

x = int(input())

i = 0
y = 100
while y < x :
    i += 1
    y = year(y)

print(i)

Solution (Python):

import math
def main():
    x = int(input())
    count = 0
    ans = 100
    while ans < x:
        ans = math.floor(ans*1.01)
        count += 1

    print(count)
main()

Solution (Python):
import math
x = int(input())
ans = 100
count = 0
for i in range(10000000000000000000):
    ans = math.floor(ans * 1.01)
    count += 1
    if ans >= x:
        print(count)
        break

Solution (Python):
def Sol(n):
    
    cur= 100
    y = 0
    while cur < n:
        cur += int(cur/100)
        y +=1
    print(y)
    
    return

    
n = int(input())









Sol(n)

Solution (Python):
money = 100
count = 0
x = int(input())
while x > money:
    money = (money * 1.01) // 1
    count += 1


print(count)

Solution (Python):
x=int(input())
a=101
b=1
while a<x:
    b+=1
    a=int(a*1.01)

print(b)

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

yokin = 100
i = 0

while(yokin < s):
  yokin = int(yokin * 1.01)
  i += 1
  
print(i)

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

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

x = int(input())

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

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

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

a = 100
b = 1.01
 
count = 0

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

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

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

for i in range(100000000):
    i += 1
    ans = ans * 1.01
    ans = int(ans)
    if x <= ans:
        print(i)
        break

Solution (Python):
from math import ceil 
import numpy as np
 
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()) 

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

Solution (Python):


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


if __name__ == '__main__':
    main()

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

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

print(ans)

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

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

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

Solution (Python):
from  math import floor
X = int(input())
bank = 100
count = 0
while bank < X:
    bank = bank + floor(bank*0.01)
    count += 1
print(count)

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

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

Solution (Python):
import math
X = int(input())
A = 100
for i in range(X):
    A = A + 0.01*A
    A = math.floor(A)

    if A >=X:
        break
print(i+1)

Solution (Python):
import math

x = int(input())

budget = 100

cnt = 0

while True:
    cnt += 1
    budget = math.floor(budget*1.01)
    if budget >= x:
        print(cnt)
        exit()

Solution (Python):
import sys


X = int(input())








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

Solution (Python):
import math

k = int(input())
cnt = 0
now = 100

while k > now:
  now = math.floor(now * 1.01)
  cnt += 1
  
print(cnt)

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

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

x = int(readline())

value = 100
cnt = 0

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

print(cnt)

Solution (Python):
import math
x=int(input())
now=100
for i in range(20000):
    now=math.floor(now*1.01)
    if now>=x:
        print(i+1)
        break

Solution (Python):
x = int(input())
y = 100
ret = 0
while x > y:
	z = y*101.0/100.0
	y = int(z)
	ret += 1


print(ret)

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

import math

current = 100

i = 0
while(True):
    i+=1
    current = math.floor(current * 1.01)
    if current >= x:
        break

print(i)

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

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

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

Solution (Python):
num=int(input())
a=0
b=100
while not a==-1:
    b=int(b*1.01)
    a += 1
    if num<=b:
        print(a)
        break

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

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

print(cnt)

Solution (Python):

x = int(input())
m = 100
for i in range(1, 1000000000000000000):
    m += int(m*0.01)

    if (m>=x):
        print(i)
        break

Solution (Python):
import math

x = int(input())
depo = 100
count = 1

while True:
    depo = math.floor(depo*1.01)
    if depo >= x:
        print(count)
        break
    count += 1

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

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

Solution (Python):
def m():
    x = int(input())
    a = 100
    ans = 0
    while a < x:
        a = int(a*1.01)
        ans += 1
    return ans


print(m())

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

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

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

print(ans)

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

print(j)

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

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

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

year = 0
sum = 100
while sum < x:
    year = year + 1
    sum = (int)(sum * 101 / 100)

print("{}".format(year))

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

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

while True:
    if money >= X:
        break
    money_ = int(money*1.01)
    money = money_
    i += 1
    
print(i)

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians

from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from functools import reduce
from bisect import bisect_left, insort_left
from heapq import heapify, heappush, heappop

INPUT = lambda: sys.stdin.readline().rstrip()
INT = lambda: int(INPUT())
MAP = lambda: map(int, INPUT().split())
S_MAP = lambda: map(str, INPUT().split())
LIST = lambda: list(map(int, INPUT().split()))
S_LIST = lambda: list(map(str, INPUT().split()))

sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7


def main():
    X = INT()

    money = 100
    for i in range(4000):
        money = int(money*1.01)
        if money >= X:
            print(i+1)
            sys.exit()


if __name__ == '__main__':
    main()

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

print(year)

Solution (Python):
count = 0

k= int(input())
start =100 
while(1):
    start =start + int(start*0.01)
    count +=1
    if start >=k:
        print(count)
        break

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

Solution (Python):
import math

if __name__ == '__main__':
    

    x = int(input())
    

    

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

Solution (Python):
x = int(input())
year = 1
deposit = 100
while(True):
  deposit = int(deposit * 1.01)
  if (x <= deposit):
    break
  year += 1
print(year)

Solution (Python):
import math

if __name__ == "__main__":
    x = int(input())

    y = 100
    i = 0
    while True:
        i += 1
        y *= 1.01
        y = math.floor(y)
        if x <= y:
            break

    print(i)

Solution (Python):


from sys import stdin


def main():
    x = int(stdin.readline())

    money = 100
    year = 0

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


if __name__ == "__main__":
    main()

Solution (Python):

from math import ceil, log
X = int(input())
ans = 0
v = 100
while v < X:
    v *= 1.01
    v = int(v)
    ans += 1
print(ans)

Solution (Python):
def percent(n):
  start = 100
  count = 0
  while(start<n):
    interest = int(start * (1/100))
    count+=1
    start += interest
    
  return count


n = int(input())
print(percent(n))

Solution (Python):
import math

x = int(input())
d = 0
k = 100
while k < x :
  k *= 1.01
  k = math.floor(k)
  d += 1
print(d)

Solution (Python):
import math

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

while(Y < X):
    Y = math.floor(1.01*Y)
    cnt += 1

print(cnt)

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

Solution (Python):
X = int(input())
def solve(X):
    lis = [0]*4000
    lis[0] = 100
    for i in range(1,4000):
        lis[i] = lis[i-1]+lis[i-1]//100
        if lis[i]>=X:
            return i
print(solve(X))

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

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

Solution (Python):




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

while True:
    risi = money//100
    money += risi
    year += 1

    if money >= x:
        print(year)
        exit()

Solution (Python):
import math
def B():
    X = int(input())
    balance = 100
    count = 0
    while balance < X:
        balance = math.floor(balance*1.01)
        count += 1
    print(count)
    
B()

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

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

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

X = int(input())

year = 0
total = 100

while True:
    year += 1
    total += math.floor(total * 1 / 100)
    if total >= X:
        print(year)
        sys.exit()

Solution (Python):
import numpy as np
num_val = int(input())
start_val = 100

cnt = 0
while start_val < num_val:
    cnt += 1
    start_val = np.floor(start_val*(1.01))
print(cnt)

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

Solution (Python):
from math import floor


def main():
    X = int(input())
    m = 100
    i = 1
    while True:
        m = floor(m * 1.01)
        if X <= m:
            print(i)
            exit()
        i = i+1


if __name__ == '__main__':
    main()

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

tmp = 100

i = 0
while target > tmp:
    tmp = int(tmp*1.01)
    i += 1

print(i)

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

while X > money:
  money += math.floor(money*0.01)
  y += 1
print(y)

Solution (Python):




import math

x = input()
x  = int(x)

now = 100
count = 0

while x>now:
    now = math.floor(now*1.01)
    count += 1
    
print(count)

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

Solution (Python):
n = int(input())
ans,a = 0,100
while n > a:
    a += a//100
    ans += 1
print(ans)

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

y = 0
while True:
    if m >= x:
        break
    y += 1
    m += int(0.01*m)
print(y)

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

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

print(y)

Solution (Python):
x = int(input())
y = 100
z = 0

while y<x:
    y = (y*1.01)//1
    z += 1

print(z)

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

x = 100
c = 0
interest = 1.01
while True:
    c += 1
    x = int(x * 1.01)  
    if x >= X:
        print(c)
        sys.exit()

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

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

Solution (Python):
'''input
1333333333
'''

x = int(input())
count =0
p = 100
ans = -1
while True:
	count += 1
	a = (p*101)//100
	if(a>=x):
		ans = count
		break;
	p = a
print(count)

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

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

print(ans)

Solution (Python):
import math

X = int(input())

money = 100
count = 0

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

print(count)

Solution (Python):
N= int(input())
ans = 0
base = 100

while True:
    base = int((base)*(1.01))
    ans += 1
    if base >= N:
        break

print(ans)

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

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

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

Solution (Python):
import math
x = int(input())
ans = 100
i = 1

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

Solution (Python):
import itertools
import math
import string
import collections
from collections import Counter
from collections import deque
import sys
sys.setrecursionlimit(2*10**5)
INF = 2**60


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


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor



dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]
x = int(input())
a = 100
cnt = 0
for _ in range(4000):
    cnt += 1
    a = math.floor(a*1.01)
    if a >= x:
        print(cnt)
        exit()

Solution (Python):


def main():
    x = int(input())
    ans = 0
    interest = 100
    while True:
        interest = int(interest * 0.01 + interest)
        ans += 1
        if interest >= x:
            print(ans)
            exit()
    
if __name__ == '__main__':
    main()

Solution (Python):
import os

import sys

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

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


X = int(sys.stdin.buffer.readline())
x = 100
cnt = 0
while True:
    x *= 1.01
    x = int(x)
    cnt += 1
    if x >= X:
        print(cnt)
        exit()

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

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

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

cnt = 0
y = 100

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