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

N = 100

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


print(ans)

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

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

Solution (Python):

import sys
import math

def solve(X: int):
    ans = 100
    cnt = 0
    while True:
        ans = int(ans * 1.01)
        cnt += 1

        if ans>=X:
            print(cnt)
            return
    
    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):
import math
x = int(input())
cnt = 100
ans = 0
for _ in range(10 ** 7):
    cnt = math.floor(cnt * 1.01)
    ans += 1
    if cnt >= x:
        break
print(ans)

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

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

Solution (Python):
import math

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

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

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

print(year)

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

Solution (Python):
x=int(input())
count=100
y=0
for i in range(4000):
  if count<x:
    count=count+int(count*0.01)
    y+=1
  else:
    print(y)
    exit()

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

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

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

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

Solution (Python):
import collections
import math
import operator as op
from functools import reduce
from collections import Counter
import numpy as np
import math
import bisect
import heapq

MOD = 1000000007


def get_inputs(cast_func=None):
    if cast_func is None:
        return input().split()
    else:
        return list(map(cast_func, input().split()))


def get_input(cast_func=None):
    if cast_func is None:
        return input()
    else:
        return cast_func(input())


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


if __name__ == '__main__':
    main()

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

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

print(y)

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

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

Solution (Python):
import math

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

Solution (Python):
import math
n=int(input())
num,cnt=100,0
while 1:
    if num>=n:break
    num *=1.01
    num=math.floor(num)
    cnt +=1

print(cnt)

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

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

bal = 100

i = 0

while(1):
    if bal >= X:
        break
    bal *= 1.01
    bal = int(bal)
    i += 1

print(i)

Solution (Python):
'''
.append(要素) リストに要素を追加
.extend(リスト) リストを連結する
.insert(場所,要素) 指定した場所に要素追加
del 配列名[場所]
-1で末尾で末尾から一つ前

sort()
sorted(reverse=true)

配列の初期化
配列名=[a]*n+[b]*m

Decimal()
'''

from sys import stdin
from itertools import accumulate, dropwhile, takewhile, groupby
import bisect
import copy
import math
from functools import reduce
from operator import mul
from collections import Counter
import itertools
import fractions

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

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

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

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

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

year = 0

while res < x:
    res = int(res + 0.01 * res)
    year = year + 1
print(year)

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

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

m = 100
year = 0

while X > m:
    year += 1
    m += int(m * 0.01)

print(year)

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


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

    


if __name__ == "__main__":
    main()

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

have = 100
year = 0

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

print(year)

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

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

y = 100
d = 0

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

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

y = 100
res = 0
while y < x:
    y = (y * 1.01) // 1
    res += 1

print(res)

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

while True:
  if x <= int(t):
    print(ans)
    exit()
  else:

    t += t // 100
    ans += 1

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

x = int(input())
t = 100
for i in range(100000):
    t = int(t*1.01)
    if t >= x:
        print(i+1)
        break

Solution (Python):

import math


def main():
    x = int(input())
    current = 100
    i = 0
    while x > current:
        r = math.floor(current * 0.01)
        current += r
        i += 1
    print(i)


if __name__ == '__main__':
    main()

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

Solution (Python):

import math

x = int(input())

n = 100

i = 0

while n < x:
    n = math.floor(n * 1.01)
    i += 1

print(i)

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

print(count)

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

x = int(stdin.readline().rstrip())
m = 100

for i in range(10000000000000):
    if (x <= m):
        print(i)
        break
    m *= 1.01
    m = int(m)

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

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

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

Solution (Python):
N = int(input())
S = 100
k = 0
while S < N:
    S = S * 101 // 100
    k += 1
print(k)

Solution (Python):

MOD = 10 ** 9 + 7

def main():
    for _ in inputt(1):
        n, = inputi()
        i, t = 0, 100
        while t < n:
            t = t + t // 100
            i += 1
        print(i)







from math import *
from heapq import *
from itertools import *
from functools import reduce, lru_cache, partial
from collections import Counter, defaultdict
import re, copy, operator, cmath
import sys, io, os, builtins
sys.setrecursionlimit(1000)





BUFSIZE = 8192
class FastIO(io.IOBase):
    newlines = 0
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = io.BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(io.IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
    if args:
        sys.stdout.write(str(args[0]))
        split = kwargs.pop("split", " ")
        for arg in args[1:]:
            sys.stdout.write(split)
            sys.stdout.write(str(arg))
    sys.stdout.write(kwargs.pop("end", "\n"))
def debug(*args, **kwargs):
    print("debug", *args, **kwargs)
    sys.stdout.flush()
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip()
inputt = lambda t = 0: range(t) if t else range(int(input()))
inputs = lambda: input().split()
inputi = lambda k = int: map(k, inputs())
inputl = lambda t = 0, k = lambda: list(inputi()): [k() for _ in range(t)] if t else list(k())





def len(a):
    if isinstance(a, range):
        return -((a.start - a.stop) // a.step)
    return builtins.len(a)
def bisect_left(a, x, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    if key == None: key = do_nothing
    while lo < hi:
        mid = (lo + hi) // 2
        if key(a[mid]) < x: lo = mid + 1
        else: hi = mid
    return lo
def bisect_right(a, x, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    if key == None: key = do_nothing
    while lo < hi:
        mid = (lo + hi) // 2
        if x < key(a[mid]): hi = mid
        else: lo = mid + 1
    return lo
def insort_left(a, x, key = None, lo = 0, hi = None):
    lo = bisect_left(a, x, key, lo, hi)
    a.insert(lo, x)
def insort_right(a, x, key = None, lo = 0, hi = None):
    lo = bisect_right(a, x, key, lo, hi)
    a.insert(lo, x)
do_nothing = lambda x: x
bisect = bisect_right
insort = insort_right
def index(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    if key == None: key = do_nothing
    i = bisect_left(a, x, key, lo, hi)
    if lo <= i < hi and key(a[i]) == x: return a[i]
    if default != None: return default
    raise ValueError
def find_lt(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    i = bisect_left(a, x, key, lo, hi)
    if lo < i <= hi: return a[i - 1]
    if default != None: return default
    raise ValueError
def find_le(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    i = bisect_right(a, x, key, lo, hi)
    if lo < i <= hi: return a[i - 1]
    if default != None: return default
    raise ValueError
def find_gt(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    i = bisect_right(a, x, key, lo, hi)
    if lo <= i < hi: return a[i]
    if default != None: return default
    raise ValueError
def find_ge(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    i = bisect_left(a, x, key, lo, hi)
    if lo <= i < hi: return a[i]
    if default != None: return default
    raise ValueError






class Tree:
    def __init__(n):
        self._n = n
        self._conn = [[] for _ in range(n)]
        self._list = [0] * n
    def connect(a, b):
        pass





class Sieve:
    def __init__(self):
        self._n = 6
        self._list = [2, 3, 5, 7, 11, 13]
    def extend(self, n):
        if n <= self._list[-1]: return
        maxbase = int(n ** 0.5) + 1
        self.extend(maxbase)
        begin = self._list[-1] + 1
        newsieve = [i for i in range(begin, n + 1)]
        for p in self.primerange(2, maxbase):
            for i in range(-begin % p, len(newsieve), p):
                newsieve[i] = 0
        self._list.extend([x for x in newsieve if x])
    def extend_to_no(self, i):
        while len(self._list) < i: 
            self.extend(int(self._list[-1] * 1.5))
    def primerange(self, a, b):
        a = max(2, a)
        if a >= b: return
        self.extend(b)
        i = self.search(a)[1]
        maxi = len(self._list) + 1
        while i < maxi:
            p = self._list[i - 1]
            if p < b:
                yield p
                i += 1
            else: return
    def search(self, n):
        if n < 2: raise ValueError
        if n > self._list[-1]: self.extend(n)
        b = bisect(self._list, n)
        if self._list[b - 1] == n: return b, b
        else: return b, b + 1
    def __contains__(self, n):
        if n < 2: raise ValueError
        if not n % 2: return n == 2
        a, b = self.search(n)
        return a == b
    def __getitem__(self, n):
        if isinstance(n, slice):
            self.extend_to_no(n.stop + 1)
            return self._list[n.start: n.stop: n.step]
        else:
            self.extend_to_no(n + 1)
            return self._list[n]

sieve = Sieve()
def isprime(n):
    if n <= sieve._list[-1]:
        return n in sieve
    for i in sieve:
        if not n % i: return False
        if n < i * i: return True
prime = sieve.__getitem__
primerange = lambda a, b = 0: sieve.primerange(a, b) if b else sieve.primerange(2, a)
def factorint(n):
    factors = []
    for i in sieve:
        if n < i * i: break
        while not n % i:
            factors.append(i)
            n //= i
    if n != 1: factors.append(n)
    return factors
factordict = lambda n: Counter(factorint(n))





if __name__ == "__main__":
    main()

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

Solution (Python):
from heapq import *
import sys
from collections import *
from itertools import *
from decimal import *
import copy
from bisect import *
import math
sys.setrecursionlimit(4100000)
def gcd(a,b):
    if(a%b==0):return(b)
    return (gcd(b,a%b))
input=lambda :sys.stdin.readline().rstrip()
X=int(input())
c=0
n=100
while n<X:
    n+=n//100
    c+=1
print(c)

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

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

Solution (Python):

x = int(input())


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

Solution (Python):
import math
n = int(input())
flg = 1
mon = 100
cnt = 0
while flg:
    mon += mon*0.01
    mon = math.floor(mon)
    cnt += 1
    
    if mon >= n:
        flg = 0
print(cnt)

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

print(count)

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

n = 100
ans = 0
for i in range(1, 10**4):
    n *= 1.01
    n *= 10
    n = n // 10
    if n >= x:
        ans = i
        break
print(ans)

Solution (Python):
n=int(input())
s=100
ans=0
for i in range(10000000000000000000):
  s=int(s*1.01)
  ans+=1
  if s>=n:
    print(ans)
    exit()

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

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

print(ans)

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

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

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

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

a=100
s=0

while a<X:
    a=a+a//100
    s=s+1

print(s)

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

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

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

Solution (Python):
import sys

input = sys.stdin.readline

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

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

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

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

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

Solution (Python):
x=int(input())
n=100
s=0
while True:
    n+=n*0.01
    n=n//1
    s+=1
    if n>=x:
        print(s)
        exit()

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

x = 100

for i in range(int(1e10)):
  if X<=x:
    print(i)
    exit()
  x =  int(x*1.01)

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

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

Solution (Python):


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

for i in range(1, 10000000000000):
    Y += Y // 100
    cnt += 1
    if X <= Y:
        print(cnt)
        exit()

Solution (Python):
x = int(input())
money = 100
time = 0
while True:
    if money >= x:
        ans = time
        break
    time += 1
    add = money // 100
    money += add
print(ans)

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

print(a)

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


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


main()

Solution (Python):
t=input()
k=100000
p=100
for i in range(1,k):
	p=int(p*1.01)
	if p>=t:
		print i
		break

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

Solution (Python):
def per(x):
    i = 100
    c = 0
    while x>i:
        c += 1
        i = int(i*1.01)
    return c

x = int(input())
print(per(x))

Solution (Python):

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

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

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

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

Solution (Python):
x = int(input())
now = 100
for kek in range(123123):
	if(now >=x):
		print(kek)
		exit(0)
	now = (now* 101) //100

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

    tmp = 100
    for i in range(1,10**10):
        tmp = int(tmp*1.01)
        if tmp >= x:
            print(i)
            return


if __name__ == '__main__':
    main()

Solution (Python):
import math

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

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

    
print(year)

Solution (Python):
import math

x = int(input())

t = 1
money = math.floor(100 * (1.01**t))

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

print(t)

Solution (Python):

import math
X = int(input())
num = 0
ans = 100

while ans < X:
    ans += math.floor(ans * 0.01)
    num += 1
    
print(num)

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

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

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

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

print(ans)

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

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

a = 100
ans = 0

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


print(ans)

Solution (Python):
X = int(input()) 
k = 0
n = 100

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

    
print(k)

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

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

def main():
    X = int(input())
    n = 100
    i = 0
    while True:
        i += 1
        n = int(n*1.01)
        if X <= n:
            break
    print(i)

if __name__ == '__main__':
    main()

Solution (Python):
import math

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

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

Solution (Python):
N=int(input())
import math
k=100
t=0
while N>k:
    k=math.floor(k*1.01)
    t+=1
print(t)

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

c = 100
i = 0
while c < x:
    c += c//100
    i += 1
print(i)

Solution (Python):





import math


inputs: list = []
while True:
    try:
        inputs.append(input().strip('\n'))
    except EOFError:
        break




x = int(inputs[0])
bill = 100
years = 0

while True:
    years += 1
    temp = bill * 1.01
    bill = math.floor(temp)
    if bill >= x:
        print(years)
        break

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

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

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

ans = 100
for i in range(1, 10**6):
  ans = int(ans * 1.01)
  if ans >= K :
    print(i)
    break

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

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

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

Solution (Python):
import math

X = float(input())

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

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

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

print(ans)

Solution (Python):


import math
inp = input()

X = int(inp)
r = 1e-2

n = 0
price = 100
while price < X:
    price = math.floor(price*(1.0+r))
    n = n + 1
print(n)

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

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

x=100
for i in range(5000):
    x*=101
    x//=100
    if(x>=X):
        print(i+1)
        break

Solution (Python):
from __future__ import print_function

import sys
sys.setrecursionlimit(500000)

import re
import array
import copy
import functools
import operator

import math
import string
import fractions
from fractions import Fraction

import collections
import itertools
import bisect

import random
import time

import heapq
from heapq import heappush
from heapq import heappop
from heapq import heappushpop
from heapq import heapify
from heapq import heapreplace
from queue import PriorityQueue as pq
from queue import Queue

from itertools import accumulate

from collections import deque
from collections import Counter

from operator import mul
from functools import reduce

input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return


















def combinations_count(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


def main():
    x = int(input().strip())
    temp=100
    for i in range(1000000000):
        if temp>=x:
            print(i)
            return
        temp=int(temp*1.01)


if __name__ == '__main__':
    main()

Solution (Python):
import sys
from io import StringIO
import unittest

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

    depo = 100
    ans = 0

    while 1:
        ans += 1
        depo = int(depo * 1.01)

        if depo >= x:
            break

    print(ans)

class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = """103"""
        output = """3"""
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = """1000000000000000000"""
        output = """3760"""
        self.assertIO(input, output)
    def test_入力例_3(self):
        input = """1333333333"""
        output = """1706"""
        self.assertIO(input, output)

if __name__ == "__main__":
    
    resolve()

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

Solution (Python):
def main():
    x = int(input())
    a = 100
    count = 0
    while x > a:
        a = int(a*1.01)
        count += 1

    print(count)


if __name__ == '__main__':
    main()

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

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

while True:
    if money >= x:
        break
    year += 1
    money += money // 100

print(year)

Solution (Python):

import copy
import random
import bisect 
import fractions 
import math
import sys
import collections

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

d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))

X = int(input())

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

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

    year+=1
print(year)

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

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

Solution (Python):

import sys
import math
import numpy as np
import itertools


n = int(input())
i = 0
a = 100
while 1:
    if a >= n:
        print(i)
        exit()
    a = int(a * 1.01)
    i += 1

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

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

print(c)

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

print(y)

Solution (Python):
def main():
    x = int(input())
    y = 100
    for i in range(0,10**18):
        if y >= x:
            print(i)
            break
        y += y // 100

if __name__ == "__main__":
    main()

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

Solution (Python):
from collections import defaultdict
from math import gcd
import time
import sys
from collections import Counter
import itertools
import math
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
start = time.time()

N = int(input())

y = 0
s = 100
while 1:
    s *= 1.01
    s = math.floor(s)
    y += 1
    if s >= N:
        print(y)
        exit()

Solution (Python):

m = 100
x = int(input())

ans = 0;
while(m < x):
	m *= 101
	m //= 100
	ans += 1

print(ans)

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

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

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

tyo = 100
nen = 0

if tyo >= x:
    print(0)
else:
    while tyo < x:
        nen+=1
        tyo = int(tyo * 1.01)
        if tyo >= x:
            print(nen)
            break

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

Solution (Python):


X=int(input())
cnt=0
Y=100
while True:
    cnt+=1
    risi=int(Y*0.01)
    Y=Y+risi
    if Y>=X:
        print(cnt)
        break

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

def f(x):
    i = 0
    while x < X:
        i += 1
        x = int(x * 1.01)
    return i

print(f(100))

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = 10**20
def I(): return int(input())
def F(): return float(input())
def S(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()

def resolve():
    X = I()
    year = 0
    yokin = 100
    while yokin<X:
        yokin = int(yokin*1.01)
        year += 1

    print(year)

if __name__ == '__main__':
    resolve()

Solution (Python):

import math

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