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

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

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


if __name__ == '__main__':
    main()

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

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

print(ctr)

Solution (Python):

import sys


def solve(X: int):
    y = 100
    ans = 0
    while y < X:
        y = int(y * 1.01)
        ans += 1
    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):
X = int(input())
count = 0
x = 100

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

print(count)

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

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


if __name__ == '__main__':
	main()

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




m=0
a=100
while a<n:
    a=a*1.01//1
    m+=1
print(m)

Solution (Python):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): 
    return list(map(int,input().split()))
def m(): 
    return map(int,input().split())
def onem(): 
    return int(input())
def s(x): 
    a = []
    if len(x) == 0:
        return []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa != x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): 
    return " ".join(map(str,x))
def max2(x): 
    return max(map(max,x))
def In(x,a): 
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False

def pow_k(x, n):
    ans = 1
    while n:
        if n % 2:
            ans *= x
        x *= x
        n >>= 1
    return ans

"""
def nibu(x,n,r):
    ll = 0
    rr = r
    while True:
        mid = (ll+rr)//2

    if rr == mid:
        return ll
    if (ここに評価入れる):
        rr = mid
    else:
        ll = mid+1
"""

n = onem()

po = 100
co = 0
while True:
    if po >= n:
        break
    co += 1
    po += po//100

print(co)

Solution (Python):

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

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

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

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

A = 100
res = 0
while A < X:
    A += int(A * 0.01)
    res += 1

print(res)

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

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

Solution (Python):
from itertools import count
from math import floor

X = int(input())

c = 100
for y in count():
    if c >= X:
        print(y)
        break
    c *= 1.01
    c = floor(c)

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

while money < X:
    res += 1
    money += (money * 0.01) // 1

print(res)

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

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

Solution (Python):
X, = [int(x) for x in input().split()]

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

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

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

Solution (Python):
import math
import sys
sys.setrecursionlimit(10**9)
X = int(input())
A = 100
i = 0
while A < X:
    A = math.floor(A*1.01)
    i+=1

print(i)

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

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

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

K = 100
year = 0
while K < N:
    K = K*101//100
    year += 1
print(year)

Solution (Python):
import sys

x = int(input())

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

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

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

while k < x:
  ans += 1
  k = math.floor(k * 101/100)
print(ans)

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

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

print(count)

Solution (Python):
from sys import stdin

def main():

    input = stdin.readline

    X = int(input())

    A = 100

    ans = 0

    while True:
        A = A + int(A * 0.01)
        ans += 1
        if X <= A:
            print(ans)
            return 0

if __name__ == "__main__":
    main()

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


if __name__ == '__main__':
    main()

Solution (Python):
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate, product
import sys
import bisect
import string
import math
import time


def I(): return int(input())


def S(): return input()


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


def MS(): return map(str, input().split())


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


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


def debug(table, *args):
    ret = []
    for name, val in table.items():
        if val in args:
            ret.append('{}: {}'.format(name, val))
    print(' | '.join(ret), file=sys.stderr)


yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**19
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

show_flg = False



def main():
    X = I()
    ans = 100

    for i in range(1, 10**19):
        ans = int(ans * 1.01)
        if ans >= X:
            print(i)
            return


if __name__ == '__main__':
    main()

Solution (Python):
if __name__ == '__main__':
    from sys import stdin
    
    import math
    input = stdin.readline

    x = int(input())

    a = 100
    for i in range(4000):
        a = math.floor(a*1.01)
        if a >= x:
            print(i+1)
            exit()

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

m = 100
res = 0

while(True):
    m *= 1.01
    m = int(m)
    res += 1

    if(m >= x): break

print(res)

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

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

money = 100

year = 0
while money < x:
    year += 1
    money += money//100

print(year)

Solution (Python):
X = int(input())
Y = 100
for ans in range(1,4000):
    Y = (Y*101)//100
    if Y >= X:
        break
print(ans)

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

print(ans)

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

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

ans = 0
A = 100
while A < X:
    A += A//100
    ans += 1

print(ans)

Solution (Python):



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


print(main())

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

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

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

Solution (Python):
X = int(input())
N = 100
ans = 0
while True:
    ans += 1
    N += int(N * 0.01)
    if N >= X:
        print(ans)
        exit()

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

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

print(ans)

Solution (Python):
from collections import deque, Counter, defaultdict
from itertools import chain, combinations
import json

import bisect
import sys
import math
import bisect
from functools import lru_cache

sys.setrecursionlimit(10 ** 8)

M = 10 ** 9 + 7
INF = 10 ** 17


def main():
    N = int(input())
    
    c = 1
    d = 100
    while True:
        d = int(d * 1.01)
        if d >= N:
            print(c)
            return
        c += 1


if __name__ == "__main__":
    main()

Solution (Python):
import sys

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


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

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

    print(cnt)


if __name__ == '__main__':
    resolve()

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

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

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

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

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

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

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

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

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

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

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

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
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 main():
    X = I()
    c = 100
    cnt = 0
    while c < X:
        c *= 1.01
        c = int(c)
        cnt += 1
    print(cnt)

main()

Solution (Python):
import sys


X = int(input())

year = 1
ans  = 100
while 1:

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

print(year)

Solution (Python):
x = int(input())
money = 100
for i in range(3800):
    money = int(money)
    if  money >= x:
        print(i)
        exit()
    money *= 1.01

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

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

Solution (Python):
import math

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

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

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

Solution (Python):
import sys

readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7


def main():
    X = int(input())
    ans = 0
    a = 100
    while True:
        ans += 1
        a = int(a*1.01)
        if a>=X:
            print(ans)
            break
if __name__ == '__main__':
    main()

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

while Y < X :
    Y = int(Y+Y*0.01)
    cnt += 1

print(cnt)

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

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

Solution (Python):
import sys
from math import ceil, floor, sqrt, sin, cos, pi
from itertools import accumulate, permutations, combinations
from fractions import gcd 
from collections import deque, Counter
from operator import itemgetter
from heapq import heappop,heappush
sys.setrecursionlimit(10**7)
def lcm(x, y): return ((x * y) // gcd(x, y)) 


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

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

m = 100

d = 0
while m < n:
    m *= 1.01
    m = int(m)
    d += 1
    
    
    
print(d)

Solution (Python):
X = int(input())
res = 0
t = 100
while X > t:
    t = (t * 1.01) // 1
    res += 1
print(res)

Solution (Python):
import sys

def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list(map(lambda x: x-1, MII()))

def DD2(d1,d2,init=0): return [[init]*d2 for _ in range(d1)]
def DD3(d1,d2,d3,init=0): return [DD2(d2,d3,init) for _ in range(d1)]

def to_bin(x: int) -> str: return format(x, 'b') 
def to_oct(x: int) -> str: return format(x, 'o') 
def to_hex(x: int) -> str: return format(x, 'x') 
MOD=10**9+7
def divc(x,y) -> int: return -(-x//y)
def divf(x,y) -> int: return x//y
def gcd(x,y):
    while y: x,y = y,x%y
    return x
def lcm(x,y): return x*y//gcd(x,y)
def enumerate_divs(n):
    """Return a tuple list of divisor of n"""
    return [(i,n//i) for i in range(1,int(n**0.5)+1) if n%i==0]
def get_primes(MAX_NUM=10**3):
    """Return a list of prime numbers n or less"""
    is_prime = [True]*(MAX_NUM+1)
    is_prime[0] = is_prime[1] = False
    for i in range(2, int(MAX_NUM**0.5)+1):
        if not is_prime[i]: continue
        for j in range(i*2, MAX_NUM+1, i):
            is_prime[j] = False
    return [i for i in range(MAX_NUM+1) if is_prime[i]]

from itertools import accumulate as acc
from collections import deque, Counter
from heapq import heapify, heappop, heappush
from bisect import bisect_left


def main():
    x = II()
    n = 100
    y = 0
    while n < x:
        n = int(n * 1.01)
        y += 1
    print(y)

if __name__ == '__main__':
    main()

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

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

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

i = 100
result = 0
while i < X:
    result += 1
    i = i * 1.01 // 1
    
print(result)

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

Solution (Python):
X = int(input())
yokin = 100
ans = 1
for i in range(100000):
    yokin = int(yokin * 1.01)
    if yokin >= X:
        print(ans)
        break
    ans += 1

Solution (Python):

import sys
input = sys.stdin.readline

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

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

Solution (Python):
def main():

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

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

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

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

Solution (Python):
import math
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())
money = 100
cnt = 0
while(money < X):
  cnt += 1
  money = int(money * 1.01)
print(cnt)

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

Solution (Python):
import collections
from collections import defaultdict
import math
import numpy as np
import re

x = int(input())

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

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

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

Solution (Python):
from math import floor


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


if __name__ == '__main__':
    main()

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

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

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

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

print(ans)

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

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

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

X = INT()
m = 100
ans = 0
while m < X:
	m = m*101//100
	ans += 1
print(ans)

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

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

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

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

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

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

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

print(ans)

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

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

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

print(ans)

Solution (Python):
import sys
input = sys.stdin.readline
X = int(input())
money = 100
for i in range(1, 10**18):
    money = int(money * 1.01)
    if money >= X:
        print(i)
        sys.exit()

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

y = 100
ans = 0

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

print(ans)

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

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

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

print(cnt)

Solution (Python):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

x = ni()
a = 100
i = 0
while a < x:
    a += a//100
    i += 1

print(i)

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

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

Solution (Python):
import sys

if __name__ == '__main__':
    x = int(sys.stdin.readline())
    m = 100
    i = 1

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

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

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

    print(cnt)



if __name__ == "__main__":
    main()

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

def s_in():
    return input()

def n_in():
    return int(input())

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

def print_l(l):
    print(' '.join(map(str, l)))

class Interval():
    def __init__(self, li):
        self.li = li
        self.n = len(li)
        self.sum_li = [li[0]]
        for i in range(1, self.n):
            self.sum_li.append(self.sum_li[i-1] + li[i])

    def sum(self, a, b=None):
        if b is None:
            return self.sum(0, a)

        res = self.sum_li[min(self.n-1, b-1)]
        if a > 0:
            res -= self.sum_li[a-1]
        return res

x=n_in()
n=100
cnt = 0

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

print(cnt)

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

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

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

print(i)

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

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

Solution (Python):
import sys
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

X = int(read())
cnt = 0
acc = 100
while acc < X:
    cnt += 1
    acc *= 1.01
    acc //= 1

print(cnt)

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

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

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

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

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

count = 0
tmp = 100
while True:
    if tmp >= x:
        print(count)
        break
    else:
        tmp = int(tmp * 1.01)
        count += 1

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

print(i)

Solution (Python):
X=int(input())
n=100
for i in range(10**10):
    if n>=X:
        print(i)
        exit()
    n+=n//100

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

Solution (Python):
def main() -> None:
    M = 100
    i = 0
    X = int(input())
    while M < X:
        i += 1
        M = int(M * 1.01)
    print(i)


if __name__ == '__main__':
    main()

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


def get_nums_l():
    return [ int(s) for s in input().split(" ")]


def get_nums_n(n):
    return [ int(input()) for _ in range(n)]


def get_all_int():
    return map(int, open(0).read().split())

def rangeI(it, l, r):
    for i, e in enumerate(it):
        if l <= i < r:
            yield e
        elif l >= r:
            break

def log(*args):
    print("DEBUG:", *args, file=sys.stderr)

MOD = 10**9+7

x = int(input())

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

print(count)

Solution (Python):

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

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

Solution (Python):

import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *


class Scanner():
    @staticmethod
    def int():
        return int(sys.stdin.readline().rstrip())

    @staticmethod
    def string():
        return sys.stdin.readline().rstrip()

    @staticmethod
    def map_int():
        return [int(x) for x in Scanner.string().split()]

    @staticmethod
    def string_list(n):
        return [Scanner.string() for i in range(n)]

    @staticmethod
    def int_list_list(n):
        return [Scanner.map_int() for i in range(n)]

    @staticmethod
    def int_cols_list(n):
        return [Scanner.int() for i in range(n)]


class Math():
    @staticmethod
    def gcd(a, b):
        if b == 0:
            return a
        return Math.gcd(b, a % b)

    @staticmethod
    def lcm(a, b):
        return (a * b) // Math.gcd(a, b)

    @staticmethod
    def divisor(n):
        res = []
        i = 1
        for i in range(1, int(n ** 0.5) + 1):
            if n % i == 0:
                res.append(i)
                if i != n // i:
                    res.append(n // i)
        return res

    @staticmethod
    def round_up(a, b):
        return -(-a // b)

    @staticmethod
    def is_prime(n):
        if n < 2:
            return False
        if n == 2:
            return True
        if n % 2 == 0:
            return False
        d = int(n ** 0.5) + 1
        for i in range(3, d + 1, 2):
            if n % i == 0:
                return False
        return True


def pop_count(x):
    x = x - ((x >> 1) & 0x5555555555555555)
    x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
    x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
    x = x + (x >> 8)
    x = x + (x >> 16)
    x = x + (x >> 32)
    return x & 0x0000007f


MOD = int(1e09) + 7
INF = int(1e15)


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


def main():
    
    solve()


if __name__ == "__main__":
    main()

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

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

Solution (Python):
x = int(input())
a = 100
y=0
while(1):
  y+=1
  r = a//100
  a+=r
  if a>=x:
  	break
print(y)

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

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

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




















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

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

print(cnt)

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

print(i)

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline


def solve():
    X = int(rl())
    
    a = 100
    ans = 0
    while a < X:
        a = a + int(a * 0.01)
        ans += 1
    print(ans)


if __name__ == '__main__':
    solve()

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

Solution (Python):
import math

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

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
    x=int(input())
    year=0
    yen=100
    while True:
        year+=1
        yen=yen*1.01//1
        if yen>=x:
            print(year)
            break

if __name__=='__main__':
    main()

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

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

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

a = 100
ans = 0
while x > a:
    a = math.floor(a*1.01)
    ans += 1

print(ans)

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

now = 100
cnt = 0
while (now < k):
    now *= 1.01
    now = int(now)
    cnt += 1

print(cnt)

Solution (Python):
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
from bisect import bisect_left,bisect_right 
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

n = inp()
now = 100
res = 0
while True:
    res += 1
    now *= 1.01
    now = int(now)
    if now >= n:
        print(res)
        break

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

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

Solution (Python):

import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1

x = int(input())
k = 100
while k <x:
  k = k * 101 // 100
  count += 1
print(count)