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
def main():
    X = int(input())
    S = 100

    for i in range(1, 20001):
        S = int(S*1.01)

        if S >= X:
            print(i)
            break

if __name__ == "__main__":
    main()

Solution (Python):

import sys


def solve(X: int):
    current = 100
    count = 0
    while current < X:
        current = int(current*1.01)
        count += 1
    print(count)
    
    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())
c = 0
m = 100
while True:
    m = int(m*1.01)
    c = c + 1
    if m >= x:
        print(c)
        break

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

Solution (Python):
import math
X=int(input())
def an(n,r=1.01):
  a=100
  for i in range(1,n+1):
     a=math.floor(a*r)
  return a

for n in range(1,10**8):
  if X<=an(n):
    print(n)
    break

Solution (Python):
x=int(input())
ans=100
years=0
while(ans<x):
    intr=(int)(0.01*ans)
    ans=ans+intr
    years=years+1
print(years)

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

Solution (Python):

from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect


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


def I(): return int(sys.stdin.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()
    bank = 100
    count = 0
    while bank < x:
        bank *= 101
        bank //= 100
        count += 1
    print(count)
    return



if __name__ == "__main__":
    solve()

Solution (Python):
import math

tmp = input().split()
X = int(tmp[0])
Xn_1 = 100
Year = 0

while True:
    Xn = Xn_1*1.01
    Year = Year + 1
    if Xn >= X:
        print(Year)
        break
    Xn_1 = math.floor(Xn)

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

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

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

Solution (Python):
import math
x = int(input())
count = 0
s = 100
while True:
    count += 1
    s = int(s*1.01)
    if s >= x:
        print(count)
        exit()

Solution (Python):
import sys
import itertools

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

X = int(read())

x = 100
for year in itertools.count():
    if x >= X:
        break
    x = x * 101 // 100
print(year)

Solution (Python):
import math

x=int(input())

m=100
i=0.01
ans=1

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

Solution (Python):
import math


I = int(input())











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




if I <= 100:
    cnt = 0

print(cnt)

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

Solution (Python):

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

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

Solution (Python):
a = int(input());
aa = 1.0;
bb = 1.01;
num = 100;

for i in range(0, 100000000000, 1):
    if (num >= a):
        print(i);
        break;
    num = num * (1.01);
    num = int(num);

Solution (Python):


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

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

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

while True:
    e += e // 100
    if e >= x:
        print(ans)
        break
    else:
        ans += 1

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

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

def year(x):
  return(x + x * 100 // 10000)


money = 100
 
  
h = 0

while x > money:
  money = year(money)
  h = h + 1
  
print(h)

Solution (Python):
import math
X=int(input())
temp = math.floor(100*0.01)

for i in range(2,1000000000):
  temp += math.floor((100+temp) * 0.01)
  
  if temp+100 >= X:
    print(i)
    exit()

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

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

year = 1
n = 100
while True:
    if n >= X:
        print(year-1)
        exit()
    n = int(n * 1.01)
    year += 1

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

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

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

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

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



syozikin = 100
ans = 0

while syozikin < X:
    syozikin = syozikin*1.01
    syozikin =syozikin  // 1
    ans = ans + 1
print(ans)

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

year = 0
while True:
    year += 1
    M = int(M * 1.01)

    if M >= X:
        break

print(year)

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

a = 100

cnt = 0

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

print(cnt)

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

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

Solution (Python):
import math
x = int(input())
count = 100
y = 0

for i in range(x):
    ans = x - count
    if ans <= 0:
        print(y)
        exit()
    else:
        ten = count * 0.01
        count += math.floor(ten)
        y += 1

Solution (Python):
import math
X=int(input())
n=1
y=100

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

print(n)

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

Solution (Python):
X = int(input())
cache = 100
y = 0

for f in range(1000000000000000000000):
    cache += cache // 100
    y += 1
    if X <= cache:
        break

print(y)

Solution (Python):
import math
n=int(input())
yen=float(100)
count=0

while yen<n :
  yen=yen*1.01
  count+=1
  yen=math.floor(yen)
print(count)

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

Solution (Python):
import math
X=int(input())
start=math.ceil(math.log(X/100,1.01))
kouza=100
for i in range(0,1000000):
  kouza=math.floor(kouza*1.01)
  
    
  if kouza >= X:
    print(i+1)
    break

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

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

print(y)

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

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

Solution (Python):
import math

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

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

if __name__ == '__main__':
    main()

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

Solution (Python):
import math
x = int(input())
money = 100
ans = 0

while True:
  if money < x :
    ans += 1
    money = money + math.floor(money*0.01)
    
  else:
    break

print(ans)

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

money = 100
interest = 0.01
i = 0
while money < x:
    money += int(money * interest)
    i += 1

print(i)

Solution (Python):
from decimal import Decimal
import math
x = int(input())
y = 0
m = Decimal(100)
while m<x:
    m = Decimal(1.01)*m
    m = math.floor(m) 
    y = y+1
print(y)

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

Solution (Python):
X = int(input())
INITIAL_AMOUNT = 100
INTEREST_RATE = 1.01

years = 0

amount = INITIAL_AMOUNT
while True:
    years += 1
    amount = int(amount * INTEREST_RATE)
    if amount >= X:
        print(years)
        exit()

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

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

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

print(count)

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

a = 100
i = 0
while True:
	i += 1
	a = int(a * 1.01)

	if(x <= a):
		print(i)
		break

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

Solution (Python):

X =int(input())
a = 100
for i in range(3761):
    a = int(a*1.01)
    if a >= X:
        print(i+1)
        exit()
    else:
        pass

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

for i in range(1, 10**18 + 1):
    a = v // 100
    v += a
    count += 1
    if v >= x:
        print(count)
        break
    else:
        pass

Solution (Python):
if __name__ == '__main__':
    x = 100
    X = int(input())
    cnt = 0
    while x < X:
        tmp_x = x * 1.01
        x = tmp_x // 1
        cnt += 1
    print(cnt)

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

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

Solution (Python):
import math

X = int(input())
Money = 100
countYear = 0
while Money < X:
    countYear += 1
    Money = math.floor(Money*1.01)

print(countYear)

Solution (Python):
import sys

X = int(input())

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

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

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

print(i)

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

x = 100
ans = 0
while x < n:
    ans += 1
    x *= 101
    x //= 100

print(ans)

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

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

print(ans)

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

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

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

zandaka = 100

i = 0
while zandaka < X:
    i += 1
    zandaka += zandaka//100

print(i)

Solution (Python):



def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**6)
    
    import math

    def dump(*args):
        sys.stderr.write(str(args))

    x = int(input())
    now = 100

    for i in range(4000):
        if now >= x:
            print(i)
            exit(0)
        now = math.floor(now*1.01)


if __name__ == '__main__':
    main()

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

print(count)

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

x = 100
for i in range(1, 3761):
    x += (x * .01)
    x = int(x)
    if x >= n:
        print(i)
        break

Solution (Python):

M = int(input())
K=1
r=0.01
s=100
i=0
while s<M:
    s=int(s*(1+r))
    i=i+1
print(i)

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

def getNextYokin():
    global yokin
    return int(yokin*1.01)

year_cnt = 0
while True:
    if X <= yokin:
        break
    yokin = getNextYokin()
    year_cnt += 1

print(year_cnt)

Solution (Python):
from math import log

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

print(cnt)

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

r = 0.01
cash  = 100.00
cnt = 0
while(cash < X):
    cnt += 1
    cash += float(cash)*r
    cash = int(cash)

    
print(cnt)

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

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

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

while 1==1:
  year += 1
  M = int(M*1.01)
  if M >= X:
    break

print(year)

Solution (Python):
x=int(input())
now=100
for i in range(1,10000000):
    tmp=now//100
    now+=tmp
    if now>=x:
        print(i)
        exit(0)

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

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

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

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

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

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

year = 0
money = 100

while money < X:
    year += 1
    money = money+(money//100)

print(year)

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

ans = 0
mon = 100

while True:
    y = mon // 100
    z = mon + y
    ans += 1
    if X <= z:
        print(ans)
        break
    mon = z

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


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

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

Solution (Python):
import math
X = int(input())
sum = 100
i=0

while True:

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

print(i)

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

m = 100
cnt = 0
while 1:
    cnt += 1
    m = m + math.floor(m * 0.01)
    if m >= x:
        break
print(cnt)

Solution (Python):
import math

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

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

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

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

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

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

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

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

Solution (Python):
from math import floor

x = int(input())

i = 0
money = 100

while money < x:
    money *= 1.01
    money = floor(money)
    i += 1
    
print(i)

Solution (Python):
x = list(map(int, input().split()))[0]
a = 100
i = 0
while True:
    a = (101 * a) // 100
    if a >= x:
        print(i + 1)
        break
    i += 1

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

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

Solution (Python):

import math

X = int(input())
A = 100
count = 0

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

print(count)

Solution (Python):
import math

x = int(input())

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

print(count)

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

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

count=0
y=100
while True:
    count+=1
    now=int(y*1.01)
    if X<=now:
        print(count)
        break
    else:
        y=now

Solution (Python):

x = int(input())
s = 100
i = 0
while s < x:
	s = int(s * (1 + 0.01))
	i += 1
print(i)

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

n = 0
m = 100

while m < X:
  kin = m // 100
  m += kin
  n += 1

print(n)

Solution (Python):
X = int(input())
y = 100
count = 0

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

Solution (Python):

N=int(input())
v=100
count=0

while True:
  if N<=v:
    break
  count+=1
  v*=1.01
  v=int(v)
print(count)

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

Solution (Python):
x = int(input())
import math
j = 100
for i in range(10**20):
    if j >= x:
        print(i)
        break
    j *= 1.01
    j = math.floor(j)

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

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

Solution (Python):
X = list(map(int,input().split()))[0]
yen = 100

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

print(i)

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

i = 1
ans = 100

while(True):


    ans = ans * 1.01
    
    if(ans >= X):
        print(i)
        break

    else:
        i += 1
        ans = int(ans)

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

for i in range(1,10000):
    if tmp*1.01//1>=X:
        print(i)
        break
    tmp*=1.01
    tmp//=1

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

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

while True:
    if a < x:
        a = a * 1.01
        counter += 1
        a = int(a)
    else:
        print(counter)
        break

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

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

Solution (Python):
x=int(input())
c=100
year=0
while (c<=x):
  if(c==x):
    break
  year+=1
  c+=(c*1//100)
print(year)

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

Solution (Python):
import math
X = int(input())
m=100
for i in range(1,4000):
    m=math.floor(m*1.01)
    if m>=X:
        ans=i
        break
print(str(ans))

Solution (Python):
import bisect
import copy
import heapq
import sys
import itertools
import math
import queue
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 10 ** 9 + 7

def read_values(): return map(int, input().split())
def read_index(): return map(lambda x: int(x) - 1, input().split())
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]
def init_dp1(init, N): return [init for _ in range(N)]
def init_dp2(init, N, M): return [[init for _ in range(M)] for _ in range(N)]


class V:
    def __init__(self, f, v=None):
        self.f = f
        self.v = v
 
    def __str__(self):
        return str(self.v)
 
    def ud(self, n):
        if n is None:
            return

        if self.v is None:
            self.v = n
            return
        self.v = self.f(self.v, n) 


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

    A = 100
    T = 0
    while A < X:
        A = int(A * 1.01)
        T += 1

    print(T)


if __name__ == "__main__":
    main()

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

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

print(i)

Solution (Python):
import math

X = int(input())
yen = 100
count = 0
while yen<X:
  yen=math.floor(1.01*yen)
  count+=1
else:
  print(count)

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



if __name__ == '__main__':
    main()

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

Solution (Python):

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

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

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

print(cnt)

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

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

while(X > yokin):
    yokin = int(yokin * 1.01)
    i = i + 1 
print(i)

Solution (Python):
X = int(input())
y = 100
flag = 1
con = 0
while flag:
  y *= 1.01
  y = int(y)
  con += 1
  if y >= X:
    flag = 0
print(con)

Solution (Python):
import math

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

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

print(n)

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

print(n)

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

Solution (Python):
import math
X = int(input())
depo = 100
for year in range(1,100000):
    depo = math.floor(depo * 1.01)
    if depo >= X:
        print(year)
        break

Solution (Python):
import math
x = int(input())
money = 100
n = 0

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

Solution (Python):
import math

X = int(input())

now = 100

for n in range(1, 3800, 1):
    now = now * 1.01
    now = int(math.floor(now))
    if now >= X:
        print(n)
        break

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

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

print(y)

Solution (Python):
r = 0.01
s = 100
x=int(input())
i = 0
while s<x:
	s = int(s * (1 + r))
	i = i + 1
print(i)

Solution (Python):
import math

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

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

print(count)

Solution (Python):
X=int(input())
M=100
for i in range(4000):
    M=M*1.01
    M=int(M)
    if M>=X:
        print(i+1)
        exit(0)

Solution (Python):



from pprint import pprint as pp
from pprint import pformat as pf

import math


if __name__ == '__main__':
    x = int(input())
    money = 100
    count = 0
    while not (money >= x):
        money = math.floor(money * 101 / 100)
        count += 1
    print(count)

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

while base < x:
    base += base * 0.01 // 1
    cnt += 1

print(cnt)

Solution (Python):
def fukuri(x):
    year = 0
    yen = 100
    while yen < x:
        yen = (yen * 1.01) // 1
        year += 1
    return year

x = int(input())
print(fukuri(x))

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

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

Solution (Python):
import math

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

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

print(ans)

Solution (Python):
import math
import sys

x = int(input())
money: int = 100

for i in range(10000):
  money = math.floor(money * 1.01)
  if money >= x:
    print(i + 1)
    sys.exit(0)

Solution (Python):
import sys

X = int(input())

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

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

a = 100
n = 1
while True:
  a = int(a * 1.01)
  if k <= a:
    print(n)
    exit()
  n += 1

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

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

for i in range(10000):
  A = A*1.01
  A = A//1
  if A >= X:
    print(i+1)
    break

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

while x > c:
    c = c * 101//100
    n += 1
print(n)

Solution (Python):
r = 0.01
s = 100
n = int(input())
i = 0

while s < n:
    s = int(s * (1 + r))
    i = i + 1
    
print(i)

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

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

money = 100
t=0
while True:
    if money < x:
        t += 1
        money *= 1.01
        money = int(money)
    else:
        break
print(t)

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

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

print(i)

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

Solution (Python):
import math
from functools import lru_cache

X = int(input())

@lru_cache(maxsize=None)
def rfn(n):
    if n == 1:
        return 101
    else:
        return math.floor(rfn(n-1)*1.01)

for i in range(1, 10000):
    if rfn(i) >= X:
        print(i)
        break

Solution (Python):
import math

X=int(input())
yen=int(100)
for i in range(3800):
  yen=int(math.floor(yen*1.01))
  
  if yen>=X:
    break
print(i+1)

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

p = 100

for i in range(100000):
    p = p*1.01
    p = math.floor(p)
    if p >= X:
        print(i+1)
        break
    else:
        i = i + 1

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

t = 100
n = 0
while t< k:
  t+=math.floor(t/100)
  n+=1
print(n)

Solution (Python):
X = int(input())
money = 100
year = 0
while money < X :

    money = money*1.01
    money = int(money)
    year = year+1

print(year)

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

print(n)

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

Solution (Python):
import numpy as np
import math

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

while True:
    a = math.floor(a * 1.01)

    count += 1

    if a >= X:
        print(count)
        exit()

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

Solution (Python):
import math
x = int(input())
k = 100
i = 0

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

Solution (Python):
from math import log 
import numpy as np
from bisect import bisect
x=int(input())
n=x
f=[100]
for i in range(1,4000):
    inte=f[-1]//100 
    f.append(f[-1]+inte) 


for i in range(len(f)):
    if f[i]>=x:
        print(i)
        break

Solution (Python):

import math
def main():

    x = int(input())
    n = 100.0
    counter = 0
    
    while True:
        counter += 1
        temp = n * 1.01
        n = int(temp)
        if n >= x:
            break
    print(counter)

if __name__ == '__main__':
    main()

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

x=100.0
for i in range(N):
    x=math.floor(x*1.01)
    if(x>=N):
        print(i+1)
        break;
    i+=1

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

for i in range(10000000000000000000):
  if y < X:
    y = int(y * 1.01)
  else:
    break
print(i)

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

print(n)

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

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

Solution (Python):
X = int(input())
val = 100
cnt = 0
while val < X:
    val += val//100
    cnt += 1

print(cnt)

Solution (Python):
X = int(input())
c = 100
y = 0

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

print(y)

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

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

Solution (Python):
import math

def main():
  X = int(input())
  bank = 100
  year = 0
  while True:
    bank =  math.floor(bank * 1.01)
    year += 1
    if bank >= X:
      print(year)
      break

if __name__ == '__main__':
  main()

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

ans=0
yokin=100
for i in range(1,X+1):
  yokin=yokin+int(yokin*0.01)
  if yokin < X:
    ans+=1
  else:
    ans+=1
    break
print(ans)

Solution (Python):
import math

n = int(input())
money = 100
counter = 0

while money < n:
    counter += 1
    money = math.floor(money * 1.01)

print(counter)

Solution (Python):
import math
x = int(input())
ret = 100
i = 1
while True:
    ret += ret // 100
    if ret >= x:
        print(i)
        break
    i += 1

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

chokin = 100
nen = 0
while x > chokin: 
    chokin = int(1.01 * chokin)
    nen += 1

print(nen)

Solution (Python):
import math

K = input()
value=100
check=True
count=0
while check:
    value=math.floor(value*1.01)

    count=count+1
    if(int(K)<=value):

        check=False
print(count)

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

print(c)

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

count=0
S=100//1
for i in range(1,10**18):
  S=S*1.01//1
  if S//N>=1:
    count=i
    break
print(count)

Solution (Python):
import sys
x = int(input())
a = 100
age = 0
while (1):
    if x <= a:
        print(age)
        sys.exit()
    else:
        age += 1
        a += a//100

Solution (Python):


import math

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

print(cnt)

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

xi=100
ans=0
while(xi<x):
    xi+=(xi//100)
    ans+=1
print(ans)

Solution (Python):
import math

F = 100
K = int(input())
count = 0

while F < K:
    F = F + math.floor(F*0.01)
    
    count += 1
print(count)