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())
steps=0
p=100
while p<x:
    p+=p//100
    steps+=1
print(steps)

Solution (Python):


import sys


def solve(X: int):
    m = 100
    ans = 0

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

    print(ans)


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):
import math
X = int(input())

yokin = 100
nensuu = 0

while yokin < X:
	yokin = math.floor(yokin * 1.01)
	nensuu += 1

print(nensuu)

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

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

Solution (Python):
import math

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

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

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

ans = 0
yokin = 100

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

Solution (Python):


import math

def resolve_v1(X: int) -> int:
    n = 1
    balance = math.floor(100 * 1.01)
    while balance < X:
        balance = math.floor(balance * 1.01)
        n += 1
    return n


if __name__ == '__main__':
    X = int(input())
    n = resolve_v1(X)
    print(n)

Solution (Python):
import math

X=int(input())


ans=0
x=100

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

print(ans)

Solution (Python):
new = 100
cnt  = 0

X = int(input())
while True:
  new = int(new*1.01)
  cnt+=1
  if new >= X:
    print(cnt) 
    break

Solution (Python):
import math
x =int(input())
count =0
cash =100
while True:
    count +=1
    tax = math.floor(cash *0.01)
    cash = cash +tax
    if x <= cash:
        print(count)
        break

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

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

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

y = 100
ans = 0
while y < x:
    ans += 1
    y = y*101//100
print(ans)

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

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

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

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

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

if __name__ == '__main__':
    solve()

Solution (Python):
a = int(input())
saving = 100
count_year = 0

while saving < a:
    saving = saving * 101 // 100
    count_year += 1
print(count_year)

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

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

print(ans)

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


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

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

p = 100
cnt = 0

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

print(cnt)

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

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

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

Solution (Python):



import math

input1 = input()
Ns = int(input1)

wallet=100
i=0

while wallet < Ns:
    wallet=math.floor(wallet*1.01)
    i=i+1

print(i)

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

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

Solution (Python):
import math

x = int(input())


monay = 100
count = 0

while True:
    monay = monay * 1.01
    monay = math.floor(monay)
    count = count + 1

    if monay >= x:
        break
    else:
        continue

print(count)

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

while yen < X:
    d = yen // 100
    yen += d
    c  += 1
print(c)

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

print(cnt)

Solution (Python):
from math import floor
def Main(X):
    i = 1
    a = 100
    while True:
        a = floor(a*1.01)
        if a >= X:
            return i
        i += 1
        
def main():
    X = int(input())
    print(Main(X))

if __name__ == '__main__':
    main()

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

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

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

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

print(b)

Solution (Python):
import math

target_yen = int(input())
years = 0
current_yen = 100

while current_yen < target_yen:
    years = years + 1
    current_yen = math.floor(current_yen * 1.01)

print(str(years))

Solution (Python):

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

print(n)

Solution (Python):
import math

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

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

if __name__ == '__main__':
    q_b()

Solution (Python):
x = float(input())
n = 100
y = 0

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

Solution (Python):
X = int(input())
x1 = 100
r = 0.01
t = 0
if 101 <= X <=10**18:
    while x1 < X:
        R = int(x1 * r)
        x1 = R + x1
        t = t + 1
    print(t)

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

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

        if deposit >= X:
            print(i)
            exit()

if __name__ == '__main__':
    main()

Solution (Python):


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

if __name__ == '__main__':
    main()

Solution (Python):
from functools import reduce
from fractions import gcd
import math
import bisect
import itertools
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
INF = float("inf")


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


if __name__ == '__main__':
    main()

Solution (Python):
x=int(input())
k=100
a=1
for i in range(1,4000):
  k=k*(1.01)//1
  if k<x:
    a=a+1
print(a)

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

n = 0
balance = 100

while(X-balance > 100):
  
  step = balance // 100
  a = balance % 100
  year = -(-(100 - a) // step)
  n += year
  balance += year * step
  
step = balance // 100
rest = X - balance
n += -(-rest // step)
print(n)

Solution (Python):
n=int(input())
def money(n):
  m=100
  for i in range(1000000):
    m*=1.01
    m=m//1
    if m>=n:
      return i+1
      break
print(money(n))

Solution (Python):
N=int(input())
def money(N):
  M=100
  for i in range(50000):
    M*=1.01
    M=M//1
    if M>=N:
      return i+1
      break
print(money(N))

Solution (Python):
import math

x = int(input())
yen = 100

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

print(year)

Solution (Python):
from sys import stdin, stdout
import math
import bisect
import datetime
from collections import defaultdict
import random

x = int(stdin.readline().strip())

now = 100
cnt = 0

while now < x:
    now *= 1.01
    now = int(now)
    cnt += 1
    
stdout.writelines(str(cnt) + '\n')

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

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

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

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

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


money = 100
count = 0

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


print(count)

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

INF = 10 ** 10

X = int(stdin.readline().rstrip())

year = 1
num = 100
while True:
    num = math.floor(num * 1.01)
    if num >= X:
        print(year)
        exit()

    
    year += 1

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

Solution (Python):
import math

X = int(input())

t = 0
m = 100

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

print(t)

Solution (Python):
x=int(input())
a=100
for i in range(100000):
    a*=101
    a//=100
    if a>=x:
        print(i+1)
        exit()

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

n = 0

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

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

m = 100
i = 1
while True:
    m *= 1.01
    m //= 1
    if m >= x:
        print(i)
        exit()
    i += 1

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

print(ans)

Solution (Python):
x = int(input())
s = float(100.0)
count = 0

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

print(count)

Solution (Python):
X, count = int(input()), 0
while ((account := account + account // 100) if count else (account := 100)) < X and (count := count + 1): pass
print(count)

Solution (Python):
from sys import exit, stdin
X = int(stdin.readline().rstrip())
deposit = 100
ans = 0
while deposit < X:
    deposit *= 1.01
    deposit = int(deposit)
    ans += 1
print(ans)

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

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

Solution (Python):
x = int(input())
b = 100
n = 0
for i in range(1,x):
  if b < x:
    b += int(b/100)
    n += 1
  else:
    break
print(n)

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

Solution (Python):

x = int(input())
tmp = 100
ans = 0
for i in range(10 ** 4):
    tmp = int(tmp * 1.01)
    ans += 1
    if tmp >= x:
        print(ans)
        exit()

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod2 = 998244353
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 list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)


def main():
    x = I()
    t = 100
    r = 0
    while t < x:
        r += 1
        t += t // 100

    return r


print(main())

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

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

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

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

print(i)

Solution (Python):







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

    def bs(m):
        inp = 100
        for i in range(m):
            inp = int(inp * 1.01)
        return inp >= x
    
    l = 0
    r = 100000
    ans = 0
    while l <= r:
        mid = (r - l) // 2 + l
        if bs(mid):
            r = mid - 1
            ans = mid
        else:
            l = mid + 1
    print(ans)
    return

if __name__ == "__main__":
    main()

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

Solution (Python):
from sys import exit

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

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

        if deposit >= X:
            print(i)
            exit()

if __name__ == '__main__':
    main()

Solution (Python):



import math

input_x = input()
x = int(input_x)

zandaka = 100
nen = 0

while zandaka < x:
    nen += 1
    zandaka = math.floor(zandaka * 1.01)

print(nen)

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

for i in range(100000000):
    s = deposit // 100
    deposit += s
    if deposit >= x:
        print(i+1)
        break

Solution (Python):
X = int(input())
D = 100
for i in range(10000):
    if D >= X:
        ans = i
        break
    D = int(D*1.01)
print(ans)

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

    X = int(input())

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


if __name__ == "__main__":
    main()

Solution (Python):
X = int(input())
cnt = 1
t = 100
while True:
    t = int(t * 1.01)
    if X <= t:
        print(cnt)
        exit()
    else:
        cnt += 1

Solution (Python):
a = [100]
for i in range(4000):
    a.append(a[-1] + a[-1] // 100)
x = int(input())
for i in range(4000):
    if a[i] >= x:
        print(i)
        exit()

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

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

print(ans)

Solution (Python):

import math
X=int(input())
M=100
Year=0
while M<X:
    M=math.floor(M*1.01)
    Year+=1
print(Year)

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):
target = int(input())
money = 100
year = 0

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

Solution (Python):
x = int(input())
num = 100
out = 0

while x > num:
  numa = num * 1.01
  num = int(numa)
  out = out +1

print(out)

Solution (Python):
import math
x = int(input())
a = 100
answer = 0

while a < x:
    a += math.floor(a * 0.01)
    answer += 1
print(answer)

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

Solution (Python):

import sys


def solve(X: int):
    y = 100
    ans = 0
    while y < X:
        y = (101 * y) // 100
        ans += 1
    print(ans)
    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 math

    x = int(input())

    deposit = 100
    for i in range(10000):
        if x <= deposit:
            print(i)
            break
        deposit = math.floor(deposit * 1.01)


if __name__ == '__main__':
    main()

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

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

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

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

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

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())
money, year = 100, 0

while True:
    if money >= X:
        print(year)
        exit()
    else:
        money = math.floor(money * 1.01)
        year += 1

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

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

print(count)

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):
X = int(input())
now = 100
ans = 0
while now < X:
    now += now//100
    ans += 1
print(ans)

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

Solution (Python):
import math
X = int(input())
total = 100
kinri = 1.01
for i in range(100, 1000000000000000000):
    total = math.floor(total * kinri)
    
    if total >= X:
        print(i-99)
        break

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

Solution (Python):
X = input()

flag = 0
asset = []
asset.append(100)
for i in range(1, 10000):
  asset.append(int(asset[i-1]*1.01))
  if asset[i] >= int(X):
    print(i)
    break

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

deposit = 100
ans = 0

while 1:
    

    if deposit >= X:
        print(ans)
        break
    else:
        deposit = deposit*101//100
        ans += 1

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

int1 = lambda x: int(x) - 1
def II(): return int(input())

def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())

def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]

INF = float('inf')

def solve():
    x = II()
    yen = 100
    for i in range(1, 10000):
        yen = int(yen * 1.01)
        if yen >= x:
            print(i)
            return


if __name__ == '__main__':
    solve()

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

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

ans = 0
S = 100

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

print(ans)

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

Solution (Python):
def solve(x):
    y = 100
    ans = 0
    while y < x:
        y = int(y * 1.01)
        ans += 1
    return ans

x = int(input())
print(solve(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 = n*101//100
    print(res)

if __name__ == '__main__':
    main()

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

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

tmp = 100

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

print(ans)

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

Solution (Python):
def solve():
    x=int(input())
    r=1+0.01
    n=1
    p=100
    while(p<x):
        p=int(p*r)
        n+=1
    print(n-1)
solve()

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

Solution (Python):
from math import floor

X = int(input())
d = 100.0
ans = 1

while True:
	d = floor(d * 1.01)
	if d >= X:
		print(ans)
		exit(0)
	ans += 1

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

'''
x == 100 * (1.01)**a
'''

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

print(a)

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

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

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

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

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

cnt = 0
while p < x:
    p += p // 100
    cnt += 1
print(cnt)

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

Solution (Python):
X = int(input().strip())
dep = 100
year = 1
while True:
    p1 = int(dep * 0.01)
    dep += p1
    if dep >= X:
        print(year)
        break
    else:
        year += 1

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


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


if __name__ == '__main__':
    main()

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

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

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

print(count)

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

while X > M:
  M = int(M*1.01)
  Y += 1
  
print(Y)

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

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

print(count)

Solution (Python):
import math

X=int(input())
m=100
a=0
for i in range(1,4000):
  m*=1.01
  m=math.floor(m)
  if m>=X:
    a=i
    break
print(a)

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

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

n = 100
result = 0

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

print(result)

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

Solution (Python):
a = int(input())
p = 100
cnt=0
while(1):
  cnt+=1
  p+=p//100
  if(p>=a):
    break
print(cnt)

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

year = 0
zandaka = 100
while True:
    year += 1
    zandaka=math.floor(zandaka*1.01)
    if zandaka >= X:
        break

print(year)

Solution (Python):
import math


def resolve():
    x = int(input())
    y = 0
    z = 100
    while z < x:
        z = math.floor(z * 1.01)
        y += 1
    print(y)


if __name__ == "__main__":
    resolve()

Solution (Python):
import math

x = int(input())

y = 0
z = 100
while x > z:
  z = int(z*1.01)
  y += 1

print(y)

Solution (Python):
import math

x = int(input())

a = 100
cnt = 0



while a < x:
    a = a*1.01
    a = int(a)
    b = str(a)

    cnt = cnt + 1


print(cnt)

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

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

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

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

Solution (Python):
from math import floor
x=int(input())
t=100
for i in range(1,100000):
    t=t+t//100
    if t>=x:
        print(i)
        break

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

Solution (Python):

x = int(input())

i = 100
y = 0

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

print(y)

Solution (Python):


import math

x = int(input())

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

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

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

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

year = 0
money = 100

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

print(year)

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

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

Solution (Python):
import math

x=int(input())
balance = 100
yrs = 0
while x > balance:
    balance += math.floor(balance*0.01)
    yrs += 1
print(yrs)

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

Solution (Python):


x = int(input())

money = 100
year = 0

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

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

Solution (Python):
x = input()

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

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

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


kouza = 100
count = 0
while X > kouza:
     kouza = int(kouza * 1.01)
     count += 1
print(count)

Solution (Python):
import math

bal = 100
count = 0
x = int(input())

while True:
    bal += math.floor(bal * 0.01)
    count += 1
    if bal >= x:
        break

print(count)

Solution (Python):
import math

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

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

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

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

Solution (Python):
import sys, math
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7

X = ri()

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

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

Solution (Python):
import math
X = int(input())
an = 100
n = 0
while True:
  if an < X:
    an = math.floor(an * 1.01)
    n += 1
  else:
    print(n)
    break

Solution (Python):
a = int(input()); count, p = 0, 100
while (p < a):
    p += p//100 
    count += 1
else:
    print(count)

Solution (Python):
zyogen=int(input())
c=0
kingaku=100
while 2>0:
  c+=1
  kingaku=int(kingaku*1.01)
  if kingaku>=zyogen:
    break
print(c)

Solution (Python):
import bisect
x = int(input())
n = 3933
me = [0] * n
me[0] = 100
for i in range(1, n):
  me[i] = int(me[i-1] * 1.01)
ans = bisect.bisect_left(me, x)
print(ans)

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

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

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

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

x=int(input().rstrip())

now=100
y=0
while now<x:
    y+=1
    now+=now//100
print(y)

Solution (Python):
import math

if __name__ == '__main__':
    x = int(input())
    count = 0
    now = 100
    while now < x:
        now = math.floor(now * 1.01)
        count += 1

    print(count)

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

Solution (Python):
import sys
x = int(input())
bank = 100
count = 0
while True:
    if bank >= x:
        print(count)
        sys.exit()
    else:
        bank *= 1.01
        bank= int(bank)
        count += 1

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

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

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

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

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

while money < x:
  money += int(money / 100)
  year += 1
  
print(year)

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

Solution (Python):
a = int(input())
b = 100
c = 0
while True:
  b += int(b / 100)
  c += 1
  if b >= a:
    print(c)
    exit()

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

money = 100
ans = 0
while money < x:
    money += int(money / 100)
    ans += 1

print(ans)

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

Solution (Python):
x=int(input())
i,a,ans=0,0,100

while 1:
    if ans>=x:
        print(i)
        break

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

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())
sum_ = 100
for i in range(1, 10**18+2):
    sum_ = int(sum_ * 1.01)
    if sum_ >= x:
        break
print(i)

Solution (Python):
mokuhyo = int(input())
yokin = 100
count = 0
while True:
  if yokin < mokuhyo:
    yokin = int(yokin*1.01)
    count += 1
  else:
    print(count)
    break

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

for i in range(10000):
    ans += 1
    sum = int(1.01*sum)
    if sum >= x:
        print(ans)
        break

Solution (Python):

x = int(input())
m = 100

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

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

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

print(n)

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

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

yokin = 100
year = 0
while True:
	if yokin >= x: break
	year += 1
	yokin += (yokin // 100)

print(year)

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

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

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

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

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