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



Sample input:
103


Sample output:
3

Submission status: Accepted

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

Submission status: Accepted

Solution code:
x = int(input())
a = 100
num = 0
while (a * 101) // 100 < x:
    a = (a * 101) // 100
    num += 1
print(num + 1)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
X=int(input())
p=100;ytd=0
while p<X:
  p=int(p*1.01)
  ytd=ytd+1
print(ytd)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
x = int(input())

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

Submission status: Accepted

Solution code:
X = int(input())

money = 100
for i in range(4000):
    if money >= X:
        print(i)
        break
    money = (money * 101) // 100

Submission status: Accepted

Solution code:
x = int(input())

money = 100
year = 0

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

print(year)

Submission status: Accepted

Solution code:
X = int(input())
A = 100
y = 0
while True:
    y += 1
    A = 1.01*A//1
    if A >= X:
        break
print(y)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
X=int(input())
A=100
cnt=0
while True:
    A=int(A*1.01)
    cnt+=1
    if A>=X:break
print(cnt)

Submission status: Accepted

Solution code:
x=int(input())
count=0
now=100
while True:
    if now>=x:
        print(count)
        exit()
    now+=int(now*(0.01))
    count+=1

Submission status: Accepted

Solution code:
import sys
import math
import collections
from collections import deque
from functools import reduce
import heapq
x = int(input())
#a, b = map(int, sys.stdin.readline().split())
#s = input()
#a = list(map(int, sys.stdin.readline().split()))

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

Submission status: Accepted

Solution code:
x = int(input())

ans = 0
tmp = 100

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

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def resolve():
    x = int(input())
    n = 100
    for i in range(1, 1000000):
        n = int(n * 1.01)
        if n >= x:
            print(i)
            return


if __name__ == '__main__':
    resolve()

Submission status: Accepted

Solution code:
x=int(input())
a=100
b=0
while a < x:
  a*=101
  a//=100
  b+=1
print(b)

Submission status: Accepted

Solution code:
MOD = 10 ** 9 + 7
INF = 10 ** 11
import sys
sys.setrecursionlimit(100000000)

def main():
    x = int(input())
    a = 100
    cnt = 0
    while a < x:
        a = a*101//100
        cnt += 1
    print(cnt)
if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
X = int(input())
now = 100
cnt = 0
while now < X:
    now *= 1.01
    now = now // 1
    cnt += 1
print(cnt)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

okane = 100

cnt = 0
while True:
  if int(okane) >= X:
    print(cnt)
    sys.exit()
  okane = okane + int(okane * 0.01)
  cnt += 1

Submission status: Accepted

Solution code:
X = int(input())
yen = 100
for i in range(1, 4000):
    yen *= 1.01
    yen = yen // 1
    if yen >= X:
        print(i)
        exit()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# abc165

x=int(input())

a=100
ans=0
while a<x:
    a*=1.01
    a//=1
    #print(a)
    ans+=1

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
x = int(input())
sub = 1
now_ch = 100
while True:
    now_ch = now_ch*1.01//1
    if now_ch >= x:
        print(sub)
        break
    else:
        sub+=1

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import bisect
import heapq
import itertools
import math
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from math import gcd
from operator import add, itemgetter, mul, xor
def cmb(n,r,mod):
  bunshi=1
  bunbo=1
  for i in range(r):
    bunbo = bunbo*(i+1)%mod
    bunshi = bunshi*(n-i)%mod
  return (bunshi*pow(bunbo,mod-2,mod))%mod
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def I(): return int(input())
def LI(): return list(map(int,input().split()))
def MI(): return map(int,input().split())
def LLI(n): return  [list(map(int, input().split())) for _ in range(n)]

x = I()
m = 100
ans = 0
while m < x:
    m = (m*0.01)//1 + m
    ans += 1
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    x = int(input())
    
    a = 100
    n = 0

    while True:
        n+=1
        a *=101
        a //= 100
        if a>=x:
            print(n)
            break
if __name__ == "__main__":
    main()

Submission status: Accepted

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

from math import floor

x = int(readline())
v = 100
for i in range(x):
    v = floor(v * 1.01)
    if v >= x:
        print(i + 1)
        exit()

Submission status: Accepted

Solution code:
from math import floor
x = int(input())
a = 100
i = 0
while(1):
    i += 1
    a *= 1.01
    a = floor(a)
    if a >= x:
        print(i)
        break

Submission status: Accepted

Solution code:
import numpy as np
import sys
import math
read = sys.stdin.readline

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

Submission status: Accepted

Solution code:
from math import floor
X = int(input())
n = 100
for i in range(10**4):
    n = floor(n*1.01)
    if n >= X:
        print(i+1)
        exit()

Submission status: Accepted

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

print(i)

Submission status: Accepted

Solution code:
# from math import factorial,sqrt,ceil,gcd
# from itertools import permutations as permus
# from collections import deque,Counter
# import re
# from functools import lru_cache # 簡単メモ化 @lru_cache(maxsize=1000)
# from decimal import Decimal, getcontext
# # getcontext().prec = 1000
# # eps = Decimal(10) ** (-100)

# import numpy as np
# import networkx as nx
# from scipy.sparse.csgraph import shortest_path, dijkstra, floyd_warshall, bellman_ford, johnson
# from scipy.sparse import csr_matrix
# from scipy.special import comb

# slist = "abcdefghijklmnopqrstuvwxyz"
X = int(input())

num = 100
ans = 0
while num<X:
    num = num*101//100
    ans += 1
print(ans)
# print(*ans)   # unpackして出力。間にスペースが入る
# for row in board:
#     print(*row,sep="")    #unpackして間にスペース入れずに出力する
# print("{:.10f}".format(ans))
# print("{:0=10d}".format(ans))

Submission status: Accepted

Solution code:
x = int(input())  # x = 1, y = 2

start = 100.0
year = 0
while start < x:
    start = (start * 1.01) // 1
    year += 1

print(year)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**6)
from math import floor,ceil,sqrt,factorial,log
from heapq import heappop, heappush, heappushpop,heapify
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
mod = 10 ** 9 + 7
inf = float('inf')
ninf = -float('inf')
 
#整数input
def ii(): return int(sys.stdin.readline().rstrip()) #int(input())
def mii(): return map(int,sys.stdin.readline().rstrip().split())
def limii(): return list(mii()) #list(map(int,input().split()))
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]
#文字列input
def ss(): return sys.stdin.readline().rstrip() #input()
def mss(): return sys.stdin.readline().rstrip().split()
def limss(): return list(mss()) #list(input().split())
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]

#本当に貪欲法か？ DP法では？？
#本当に貪欲法か？ DP法では？？
#本当に貪欲法か？ DP法では？？


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

Submission status: Accepted

Solution code:
# import numpy as np
# import math
# import copy
# from collections import deque
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(10000)


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

    now = 100
    res = 0

    while True:
        res += 1
        now *= 1.01
        now = int(now)
        if now >= X:
            break

    print(res)



main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
x = int(input())
a = 100
cnt = 0
while True:
    a += math.floor(a*0.01)
    cnt += 1
    if a >= x:
        print(cnt)
        exit()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import itertools
if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
    
money=100
cnt=0
x=int(input())
while money<x:
	money=int(money*1.01)
	cnt+=1
	
print(cnt)

Submission status: Accepted

Solution code:
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def resolve():
    X = ir()
    tmp = 100
    ans = 0
    while tmp < X:
        tmp = int(tmp*1.01)
        ans += 1
    print(ans)
resolve()

Submission status: Accepted

Solution code:
import math

N = int(input())

OKANE = 100
counter = 0

while OKANE < N:
    OKANE = math.floor(OKANE * 1.01)
    counter += 1
    
    
print(counter)

Submission status: Accepted

Solution code:
X = int(input())

start = 100
year = 0

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

print(year)

Submission status: Accepted

Solution code:
k = int(input())
count = 0
nach = 100
while k > nach:
    nach *= 101
    nach //= 100
    count += 1
print(count)

Submission status: Accepted

Solution code:
def LI():return list(map(int,input().split()))

# for i in range(10):
#     print(i&1^0)

x=int(input())
m=100
for i in range(5000):
    m=int(m*1.01)
    if m>=x:
        print(i+1)
        exit()

Submission status: Accepted

Solution code:
x  = int(input())
amount = 100
cnt = 0

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

print(cnt)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

import sys

DEBUG = False

def read(t):
    return t(sys.stdin.readline().rstrip())


def read_list(t, sep = " "):
    return [t(s) for s in sys.stdin.readline().rstrip().split(sep)]


def dprint(*args, **kwargs):
    if DEBUG:
        print(*args, **kwargs)
    return


def main():
    x = read(int)

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


if __name__ == "__main__":
    main()

Submission status: Accepted

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


print(ans)

Submission status: Accepted

Solution code:
# /usr/bin/python3
# -*- coding: utf-8 -*-
from queue import Queue
from queue import LifoQueue as Stack
from math import sqrt, floor, ceil, log2, log10, pi
from fractions import gcd
from itertools import permutations, combinations
from operator import itemgetter
from functools import cmp_to_key


INF=1001001001
__MOD__=(10**9)+7
yn = 'YNeos'
judge = False
cnt = 0
ans = None


def lcm(a, b):
    return (a*b) // gcd(a,b)

def intinput():
    return int(input())

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

def lineinputs(func=intinput):
    datas = []
    while True:
        try:
            datas.append(func())
        except EOFError:
            break
    return datas

class ModInt():
    def __init__(self, x):
        self.__x = (x % __MOD__)
    def __add__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x + other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x + other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __radd__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x + self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x + self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __sub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x - other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x - other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rsub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x - self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x - self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __mul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rmul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x * self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x * self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __truediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rtruediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x * self.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x * self.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __pow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(self.__x, other.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(self.__x, other.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")
    def __rpow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(other.__x, self.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(other.__x, self.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")

    def __modinv(self, m=__MOD__):
        a = self.__x
        if a == 0:
            raise ZeroDivisionError()
        if gcd(a, m) != 1:
            raise Exception("%sの逆数は求まりません。" % a)
        b, u, v = m, 1, 0
        while b != 0:
            t = a//b;
            a -= t*b
            a, b = b, a
            u -= t * v
            u, v = v, u
        u %= m
        if u < 0:
            u += m
        return u
    def __int__(self):
        return self.__x
    def __str__(self):
        return str(self.__x)



if __name__ == '__main__':
    X = intinput()

    yokin, i = 100, 1
    
    while True:
        yokin = int(yokin * 1.01)
        if yokin >= X:
            break
        i += 1
    # 出力
    print(i)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
X = int(input())

m = 100
cnt = 0
while m < X:
    m = (m*1.01)//1
    cnt += 1
print(cnt)

Submission status: Accepted

Solution code:
import math

x = int(input())

i = 0
n = 100

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
x = int(input())
p = 100
for i in range(1, 10000):
    p = int(p * 1.01)
    if p >= x:
        print(i)
        exit()

Submission status: Accepted

Solution code:
X = int(input())
a, tmp = 100, 0

while True:
    tmp += 1
    a += a // 100
    if a >= X:
        print(tmp)
        break

Submission status: Accepted

Solution code:
k = int(input())
ans = 0
m = 100
while True:
    if m >= k:
        break
    m = int(m*1.01)
    ans += 1

print(ans)

Submission status: Accepted

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

print(count)

Submission status: Accepted

Solution code:
def main():
    X = int(input())
    now = 100
    year = 0
    while now < X:
        add = now//100
        now += add
        year += 1
    print(year)
    return
main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

X = int(input())
m = 100

counter = 0
while (m < X):
    m = int(m * 1.01)
    counter += 1
print(counter)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from math import log, ceil

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

Submission status: Accepted

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

Submission status: Accepted

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

print(ans)

Submission status: Accepted

Solution code:
#
# 　　  ⋀_⋀　 
#　　  (･ω･)  
# .／ Ｕ ∽ Ｕ＼
#  │＊　合　＊│
#  │＊　格　＊│ 
#  │＊　祈　＊│ 
#  │＊　願　＊│ 
#  │＊　　　＊│ 
#      ￣
#
import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,sqrt,factorial,hypot,log #log2ないｙｐ
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from fractions import gcd
from random import randint
def ceil(a,b): return (a+b-1)//b
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    X=I()
    N=100
    ans=0
    while(X>N):
        N+=N//100
        ans+=1
    print(ans)
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys


def solve(X: int):
    ct = 0
    yo = 100
    while yo < X:
        yo *= 1.01
        yo = int(yo)
        ct += 1
    print(ct)
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    X = int(next(tokens))  # type: int
    solve(X)

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

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

Submission status: Accepted

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

print(ans)

Submission status: Accepted

Solution code:
x = int(input())

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

Submission status: Accepted

Solution code:
import sys
import math
from collections import Counter
import itertools
import fractions
#from functools import reduce

# 入力を整数に変換して受け取る
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())
# 入力全てを整数に変換したものの配列を受け取る
def LI(): return list(map(int, sys.stdin.readline().split()))
# 入力全てを整数に変換して1引いたものの配列を受け取る
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SR(): return sys.stdin.readline().rstrip()

ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_uppercase2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'

# リストを改行区切りで出力する
p2D = lambda x: print(*x, sep="\n")
p2E = lambda x: print(''.join(x))
p2S = lambda x: print(*x, sep=" ")

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

# sys.setrecursionlimit(100000)
input = sys.stdin.buffer.readline
INF = 2**62-1

def read_int():
    return int(input())


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


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(X):
    T = 100
    for i in range(INF):
        T *= 1.01
        T = int(T)
        if X <= T:
            return i + 1


def main():
    X = read_int()
    print(slv(X))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
x = int(input())
p = 100
for i in range(1000000):
    p += int(p/100)
    if x <= p:
        print(i+1)
        break

Submission status: Accepted

Solution code:
I = int(input())
current = 100
num = 0

while(current < I):
    current = int(current + current*0.01)
    num += 1


print(num)

Submission status: Accepted

Solution code:
X = int(input())

K = 100
cnt = 0
while(K<X):
    K *= 1.01
    K = K//1
    cnt += 1
    # print(K)
print(cnt)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
X = int(input())

ans = 100
n = 1
while ans < X:
    ans *= 1.01
    ans = int(ans)
    if ans >= X:
        break
    n += 1
print(n)

Submission status: Accepted

Solution code:
x=int(input())
mo=100.0

for i in range(1,4000):
    mo=mo*1.01
    mo=mo//1
    if (mo>=x):
        print(i)
        break

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

X = int(input())

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

Submission status: Accepted

Solution code:
X = int(input())

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
x = int(input())
money = 100
count = 0

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

print(count)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#import sys
MOD = 10 ** 9 + 7
INFI = 10**10
#input = sys.stdin.readline
import math

import itertools
import heapq
#import bisect

import copy
from functools import lru_cache

def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default

#    h,w,a,b = map(int, input().split())
#    c = [[0 for j in range(n)] for i in range(n)]

def ret(a):
    c=[None]*(len(a)-1)
    if len(a)==1:
        return a[0]
    elif len(a)==0:
        return 0
    for i in range(1,len(a)):
        c[i-1]=abs(a[i]-a[i-1])
    return ret(c)


def main():
    x=int(input())
    y=0
    yen=100
    while True:
        temp=yen//100
        yen+=temp
        y+=1
        if yen>=x:
            break
    print(y)



if __name__ == "__main__":

    main()

Submission status: Accepted

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