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())
ans = 0
a = 100
while True:
    if a >= x:
        break
    a = int(a * 1.01)
    ans += 1

print(ans)

Solution (Python):

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


if __name__ == "__main__":
    main()

Solution (Python):
import sys
sys.setrecursionlimit(1000000000)
import math
from math import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations, chain
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok

def get_inv(n, modp):
    return pow(n, modp-2, modp)

def factorials_list(n, modp):    
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1-1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs

def comb(n, k, modp):
    num = 1
    for i in range(n, n-k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k+1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp

def comb_from_list(n, k, modp, fs, invs):   
    return fs[n] * invs[n-k] * invs[k] % modp



class UnionFindEx:
    def __init__(self, size):
        
        self.roots = [-1] * size
    def getRootID(self, i):
        r = self.roots[i]
        if r < 0:   
            return i
        else:
            r = self.getRootID(r)
            self.roots[i] = r
            return r
    def getGroupSize(self, i):
        return -self.roots[self.getRootID(i)]
    def connect(self, i, j):
        r1, r2 = self.getRootID(i), self.getRootID(j)
        if r1 == r2:
            return False
        if self.getGroupSize(r1) < self.getGroupSize(r2):
            r1, r2 = r2, r1
        self.roots[r1] += self.roots[r2]    
        self.roots[r2] = r1
        return True

Yes = 'Yes'
No = 'No'


def main():
    m = 100
    X=ii()
    for i in count(1):
        m += (m//100)
        if m >= X:
            print(i)
            return


main()

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

Solution (Python):
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
import math
from copy import deepcopy
import queue

Mod = 1000000007
  
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[py] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)

def main():  
    mon = 100
    ans = 0
    x = int(input())
    while mon < x:
        mon *= 1.01
        mon = math.floor(mon)
        ans += 1
    print(ans)
if __name__ == "__main__":
    main()

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush

from decimal import *
































def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]

inf = float('inf')
mod = 1000000007




def main():
	X = inputInt()

	ans = 0
	yen = 100

	if yen >= X:
		print("0")
		sys.exit()

	while True:
		if yen >= X:
			break

		ans += 1
		yen = yen + (yen // 100)

	print(ans)





def combination(n, r, mod=10**9+7):
    r = min(r, n-r)
    res = 1
    for i in range(r):
        res = res * (n - i) * modinv(i+1, mod) % mod
    return res


def modinv(a, mod=10**9+7):
    return pow(a, mod-2, mod)

def egcd(a, b):
    if a == 0:
        return b, 0, 1
    else:
        g, y, x = egcd(b % a, a)
        return g, x - (b // a) * y, y



def H(n, r, mod=10**9+7):
	
	
    return combination(n+r-1, r, mod)


class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        
        
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv



def dfs(graph,parent,counter,edge):
    stk = []
    stk.append(edge)
    while len(stk) > 0:
        p = stk.pop()
        for e in graph[p]:
            if parent[p] == e:
                continue
            else:
                parent[e] = p
                counter[e] += counter[p]
                stk.append(e)

if __name__ == "__main__":
	main()

Solution (Python):

import sys


def solve(X: int):
    n = 100
    e =  0
    while (n < X):
        n = int(1.01*n)
        e += 1
    print(e)
    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())
money = 100
count = 0
while money<x:
    money=int(money*1.01)
    count+=1
print(count)

Solution (Python):
def main():
    x = int(input())
    k = 0
    y = 100
    for i in range(100000000):
        k = k + 1
        hukuri = int(y * 0.01)
        y = y + hukuri
        if y >= x:
            print(k)
            break
if __name__ == '__main__':
    main()

Solution (Python):
import sys
import math
import fractions
from collections import deque
from collections import defaultdict
sys.setrecursionlimit(10**7)

X = int(input())

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

print(cnt)

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

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

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

Solution (Python):
import heapq
from collections import defaultdict, deque
from math import ceil, factorial, gcd
from itertools import accumulate, permutations
import sys
import bisect

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

si = lambda: input().strip()
ii = lambda: int(input())
mii = lambda: map(int, input().split())
msi = lambda: map(str, input().split())
lmii = lambda: list(map(int, input().split()))
lmsi = lambda: list(map(str, input().split()))
smii = lambda: sorted(map(int, input().split()))



x = ii()

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

print(i)

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

a = 100
ans = 0

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

print(ans)

Solution (Python):
import sys
X = int(sys.stdin.readline())
T = 100
ans = 0
while T < X:
    T = int(T * 1.01)
    ans += 1
print(ans)

Solution (Python):
import sys
import math
import bisect






INF = sys.maxsize
MOD = 10 ** 9 + 7



moto = 100
rishi = 1.01
k = int(input())

cnt = 0
while True:
    cnt += 1
    moto = int(float(moto)*rishi)
    if moto >= k:
        print(cnt)
        exit(0)

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

Solution (Python):


from pprint import pprint
from collections import deque, defaultdict
import sys

sys.setrecursionlimit(10 ** 6)
input = sys.stdin.buffer.readline
INF = float("inf")

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

print(year)

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

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

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

print(y)

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

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

while X > money:
    counter += 1
    money = int(money * 1.01)

print(counter)

Solution (Python):

from math import floor

X = int(input())

year = 0
money = 100

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

print(year)

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

def resolve():

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

resolve()

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

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

Solution (Python):
import sys

stdin = sys.stdin
inf = 1 << 60
mod = 1000000007

ni      = lambda: int(ns())
nin     = lambda y: [ni() for _ in range(y)]
na      = lambda: list(map(int, stdin.readline().split()))
nan     = lambda y: [na() for _ in range(y)]
nf      = lambda: float(ns())
nfn     = lambda y: [nf() for _ in range(y)]
nfa     = lambda: list(map(float, stdin.readline().split()))
nfan    = lambda y: [nfa() for _ in range(y)]
ns      = lambda: stdin.readline().rstrip()
nsn     = lambda y: [ns() for _ in range(y)]
ncl     = lambda y: [list(ns()) for _ in range(y)]
nas     = lambda: stdin.readline().split()

x = ni()

ans = 0
res = 100
while res < x:
    res += res // 100
    ans += 1

print(ans)

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

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

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

print(cnt)

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

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

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

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

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

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

print(count)

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

i=1
v=100
while 1:
    v=int(v*1.01)

    if v>=n:
        print(i)
        exit()
    i+=1

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

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

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

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

Solution (Python):



X = int(input())
m = 100
y = 1

while True:
    m = int(m * 1.01)
    if m >= X:
        print(y)
        exit()
    y += 1

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

ans=100
now=100
cnt=0
while(True):
  if X<=now:
    break
  else:
    now=int(now+now*0.01)
    cnt+=1
print(cnt)

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

c = 100
ans = 0

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

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

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

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

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


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

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

Solution (Python):

from math import floor
X = int(input())
S = 100
for i in range(1, 10**6):
    S = floor(S * 1.01)
    if S >= X:
        print(i)
        exit()

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

Solution (Python):
X = int(input())
balance = 100
years = 0
while True:
    years += 1
    balance = balance * 101 // 100
    if balance >= X:
        print(years)
        break

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

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

    print(ans)


if __name__ == "__main__":
    main()

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

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

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

print(c)

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

count = 0
while True:
  count += 1
  Y = math.floor(Y*1.01)
  if Y >= X:
    print(count)
    break

Solution (Python):
import math
b=int(input())
a=100

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

Solution (Python):
X = int(input())
n = 100
for k in range(1000000000):
    n = int(n*1.01)
    if n >= X:
        print(k+1)
        break

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

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

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

print(ans)

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

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

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

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

Solution (Python):
def main():
    X = int(input())
    current = 100
    for i in range(10000):
        if current >= X:
            print(i)
            return
        current = current * 101 // 100


if __name__ == "__main__":
    main()

Solution (Python):
import math

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

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin, log, log10, gcd
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits

def debug(*args):
    if debugmode:
        print(*args)
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def FLOAT(): return float(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
dx = [0, 1, 0, -1, 1, -1, -1, 1]
dy = [1, 0, -1, 0, 1, -1, 1, -1]
debugmode = True

x = INT()
a = 100
for i in range(100000):
    a *= 1.01
    a = int(a)
    if a >= x:
        print(i + 1)
        exit()

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

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

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

for i in range(1,4000):
    y = int(y*1.01)
    if x <= y:
        print(i)
        break

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


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


if __name__ == '__main__':
    main()

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

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

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

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

x = ii()
ans = 0
ima = 100
while True:
    ans += 1
    ima = int(ima*1.01)
    if x <= ima:
        print(ans)
        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())
ans = 0
a = 100
while a < X:
    a = int(a*1.01)
    ans += 1
print(ans)

Solution (Python):
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy

X = int(input())

A = 100
cnt = 0

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

print(cnt)

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

ans = 0
total = 100
while True:
    ans += 1
    total += total // 100
    if total >= X:
        print(ans)
        exit()

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


times = 0
val = 100
while(1):
    val = int(val * 1.01)
    times += 1

    if val >= X:
        break

print(times)

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

while 1:
    a=int(a*1.01)
    if a>=x:
        print(co)
        exit()
    co+=1

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

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

Solution (Python):
def solve(x):
    res = 0
    v = 100
    while True:
        v = int(v * 1.01)
        res += 1
        if v >= x:
            return res


def main():
    x = int(input())
    res = solve(x)
    print(res)


def test():
    assert solve(103) == 3
    assert solve(1000000000000000000) == 3760
    assert solve(1333333333) == 1706


if __name__ == "__main__":
    test()
    main()

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

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

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

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

a = 100
for r in range(1,4000):
    a = int(1.01*a)
    if a >= X:
        print(r)
        break

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

Solution (Python):


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

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

    print(count)


if __name__ == "__main__":
    resolve()

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

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

print(cnt)

Solution (Python):
import sys


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


def main():
    X = int(input())
    T = 100
    cnt = 0
    while T < X:
        T += T // 100
        cnt += 1
    print(cnt)


if __name__ == "__main__":
    main()

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 = 0
money = 100
while True:
    money = int(money * 1.01)
    ans += 1
    if money >= x:
        print(ans)
        exit()

Solution (Python):
mod = 1000000007
eps = 10**-9


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

    x = int(input())

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


if __name__ == '__main__':
    main()

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

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

s = 100.0
n = 0
while s < x:
    s = int(s * 1.01)
    n += 1
print(n)

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

Solution (Python):

import sys
input = sys.stdin.buffer.readline


from collections import defaultdict

con = 10 ** 9 + 7

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


def main():
	X = int(input())
	var = 100
	for i in range(4000):
		var = int(var * 1.01 // 1)
		if var >= X:
			print(i + 1)
			return

	


if __name__ == '__main__':
	main()

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

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

money = 100
n = 0
while money < x:
    n += 1
    money *= 1.01
    money //= 1

print(n)

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

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

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

print(year)

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

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

Solution (Python):

N=int(input())


flag=True
A=100
c=0
while flag==True:
    c+=1
    A+=int(A*0.01)

    if A>=N:
        print(c)
        flag=False

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

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

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

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

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

import math

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

print(year)

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

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

print(year)

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

count = 0
base = 100
while base < N:
    base *= 1.01
    base = int(base)
    count += 1
    
print(count)

Solution (Python):



def solve(*args: str) -> str:
    x = int(args[0])

    ret = 0
    p = 100
    while p < x:
        p = int(p*1.01)
        ret += 1

    return str(ret)


if __name__ == "__main__":
    print(solve(*(open(0).read().splitlines())))

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

Solution (Python):

import sys


def solve(X: int):
    i = 0
    okane = 100
    while okane < X:
        okane = int(okane * 1.01)
        i += 1
    print(i)
    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())

N = 100
p = 0
while N < X:
  p += 1
  N = N * 1.01
  N = N // 1
  
print(p)

Solution (Python):

import sys


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

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

Solution (Python):
def n0():return int(input())
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(input()) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]

x=n0()
y=100

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

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

Solution (Python):

x = int(input())

a = 100

ans = 0

while True:
  a += int(a*(0.01))
  ans += 1
  if a >= x:
    break

print(ans)

Solution (Python):
import sys

x = int(input())

y = 100
result = 0
while y < x:
	interest = y // 100
	y = y + interest
	result += 1

print(result)

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

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

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

print(c)

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

print(ans)

Solution (Python):
x=int(input())
total=100
import math
for i in range(10**5):
    total*=1.01
    total=math.floor(total)
    if total>=x:
        print(i+1)
        exit()

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

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

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))

x=INT()
k=100
n=0
while True:
    if k>=x:
       print(n)
       exit()
    k=int(k*1.01)
    n+=1

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

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

c = 100

for i in range(1,4000):
  c = int( c * 1.01 )
  if c >= X:
    print(i)
    break

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

v = 100

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

print(ans)

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

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

Solution (Python):















mod = int(1e9+7)
INF = 1<<29
lINF = 1<<35

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

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

if __name__=='__main__':
    main()

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

Solution (Python):

x = int(input())



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

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

for i in range(1,10000):
    cur*=101
    cur//=100
    if cur>=X:
        print(i)
        break

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

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


ans = 100
for i in range(1,1000000):
	ans *= 1.01
	ans = int(ans)
	if ans >=X:
		print(i)
		exit()

Solution (Python):
import math

x = int(input())
yen = 100

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

print(ans)

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

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

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

Solution (Python):
import math

X = int(input())
ans = 0
cur = 100
while True:
    if cur >= X:
        print(ans)
        break
    else:
        ans += 1
        cur = math.floor(cur * 1.01)

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


if __name__ == '__main__':
    main()

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

ans=0
while x>money:
    money=int(money*1.01)
    ans+=1
print(ans)

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

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

X = int(input())
now = 100
ans = 0
while(now < X):
    ans += 1
    now *= 101
    now //= 100

print(ans)