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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

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

Submission status: Accepted

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

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

print(ans)

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

Solution code:
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()

Submission status: Accepted

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

y = 100
ans = 0

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

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
x = int(input())

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

print(cnt)

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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

Submission status: Accepted

Solution code:
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()

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

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

Submission status: Accepted

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

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

print(i)

Submission status: Accepted

Solution code:
X = int(input())

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

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
x = int(input())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
x = int(input())

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

Submission status: Accepted

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

print(i)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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()

Submission status: Accepted

Solution code:
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(" ")]

# 改行区切りの入力をn行読み込んで数値リストにして返します。
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)

Submission status: Accepted

Solution code:
# 金利1%
X = int(input())
ans = 0
now = 100
while X > now:
    ans += 1
    now = int(now * 1.01)
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
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():
    # sys.stdin = open("sample.txt")
    solve()


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 6)
#from collections import defaultdict
#d = defaultdict(int)
#import fractions
#import math
#import collections
#from collections import deque
#from bisect import bisect_left
#from bisect import insort_left
#N = int(input())
#A = list(map(int,input().split()))
#S = list(input())
#S.remove("\n")
#N,M = map(int,input().split())
#S,T = map(str,input().split())
#A = [int(input()) for _ in range(N)]
#S = [input() for _ in range(N)]
#A = [list(map(int,input().split())) for _ in range(N)]
#import itertools
#import heapq
#import numpy as np
X = int(input())
c = 100
d = 0
while c < X:
    c *= 1.01
    c = int(c)
    d += 1
print(d)

Submission status: Accepted

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

print(cnt)

Submission status: Accepted

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

print(i)

Submission status: Accepted

Solution code:
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()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

print(ans)

Submission status: Accepted

Solution code:
k = int(input())

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

print(cnt)

Submission status: Accepted

Solution code:
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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
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)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 7)

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines


import math


X = int(input())
ans = 0
t = 100.0

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

print(ans)

Submission status: Accepted

Solution code:
import math
X = int(input())
temp = 100
for i in range(10 ** 6):
    temp = int(temp * 1.01)
    if temp >= X:
        print(i + 1)
        break

Submission status: Accepted

Solution code:
#整数の入力
N = int(input())

ans = 100
count = 0
while(ans < N):
  ans = ans + int(ans/100)
  count = count + 1
  
  
print(count)

Submission status: Accepted

Solution code:
import math

X = int(input())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import heapq
import re
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from math import factorial, sqrt, ceil, gcd
from functools import lru_cache, reduce
INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)

# UnionFind
class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

# ダイクストラ
def dijkstra_heap(s, edge, n):
    #始点sから各頂点への最短距離
    d = [10**20] * n
    used = [True] * n #True:未確定
    d[s] = 0
    used[s] = False
    edgelist = []
    for a,b in edge[s]:
        heapq.heappush(edgelist,a*(10**6)+b)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        #まだ使われてない頂点の中から最小の距離のものを探す
        if not used[minedge%(10**6)]:
            continue
        v = minedge%(10**6)
        d[v] = minedge//(10**6)
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
    return d

# 素因数分解
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

# 2数の最小公倍数
def lcm(x, y):
    return (x * y) // gcd(x, y)

# リストの要素の最小公倍数
def lcm_list(numbers):
    return reduce(lcm, numbers, 1)

# リストの要素の最大公約数
def gcd_list(numbers):
    return reduce(gcd, numbers)

# 素数判定
def is_prime(n):
    if n <= 1:
        return False
    p = 2
    while True:
        if p ** 2 > n:
            break
        if n % p == 0:
            return False
        p += 1
    return True


# limit以下の素数を列挙
def eratosthenes(limit):
    A = [i for i in range(2, limit+1)]
    P = []

    while True:
        prime = min(A)
        
        if prime > sqrt(limit):
            break
            
        P.append(prime)
            
        i = 0
        while i < len(A):
            if A[i] % prime == 0:
                A.pop(i)
                continue
            i += 1
            
    for a in A:
        P.append(a)
            
    return P

# 同じものを含む順列
def permutation_with_duplicates(L):

    if L == []:
        return [[]]

    else:
        ret = []

        # set（集合）型で重複を削除、ソート
        S = sorted(set(L))

        for i in S:

            data = L[:]
            data.remove(i)

            for j in permutation_with_duplicates(data):
                ret.append([i] + j)

        return ret


# ここから書き始める
x = int(input())
ans = 0
a = 100
while a < x:
    a *= 1.01
    a = int(a)
    ans += 1
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
x = int(input())

y = 1
s = 100
while s<x:
    s = int(s*1.01)
    y += 1
print(y-1)

Submission status: Accepted

Solution code:
x = int(input().strip())
a = 100
ans = 0
while True:
    a *= 1.01
    a = int(a)
    ans += 1
    if x <= a:
        print(ans)
        exit()

Submission status: Accepted

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

p = 100
res = 0

while p < X:
    p = math.floor(1.01*p)
    res += 1

print(res)

Submission status: Accepted

Solution code:
import sys
x=int(input())
a=100
for i in range(10**6):
  a=int(a*1.01)
  if a>=x:
    print(i+1)
    sys.exit()

Submission status: Accepted

Solution code:
x=int(input())
a=100
cnt=0
while x>a:
    cnt+=1
    a=a*1.01//1
print(cnt)

Submission status: Accepted

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

Submission status: Accepted

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

    m = 100

    k = 0
    while m < X:
        k += 1
        m += m // 100
    print(k)


if __name__ == '__main__':
    main()

# import sys
# input = sys.stdin.readline
# 
# sys.setrecursionlimit(10 ** 7)
# 
# (int(x)-1 for x in input().split())
# rstrip()
#
# def binary_search(*, ok, ng, func):
#     while abs(ok - ng) > 1:
#         mid = (ok + ng) // 2
#         if func(mid):
#             ok = mid
#         else:
#             ng = mid
#     return ok

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline


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

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


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
def I():
  return input()
def II():
  return int(input())
def MII():
  return map(int, input().split())
def LMII():
  return list(map(int, input().split()))

n = II()
x = 0
m = 100
while m < n:
  m = m*101//100
  x += 1
  
print(x)

Submission status: Accepted

Solution code:
#MLE注意！0や1のケースに注意

def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    #from collections import defaultdict
    from itertools import combinations, permutations, accumulate, groupby, product
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    import math
    from math import gcd

    #inf = 10**17
    #mod = 10**9 + 7

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
def main():
    X = int( input())
    now = 100
    for i in range(100000):
        now = now*101//100
        if now >= X:
            print(i+1)
            return
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
X = int(input())
ans = 0
money = 100

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

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from collections import Counter # a = Counter(A).most_common()
#from itertools import accumulate #list(accumulate(A))
import math
N = ii()
a = 100
n = 0
while True:
    a = math.floor(a * 1.01)
    n += 1
    if a >= N:
        print(n)
        exit()

Submission status: Accepted

Solution code:
a = int(input())

prev = 100
days = 0
while prev < a:
	add = (prev * 1) // 100
	prev += add
	days += 1

print(days)

Submission status: Accepted

Solution code:
import math

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.buffer.readline

from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
from collections import deque, defaultdict
from itertools import combinations, permutations
from itertools import accumulate
from math import ceil, sqrt, pi

MOD = 10 ** 9 + 7
INF = 10 ** 18

X = int(input())

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

Submission status: Accepted

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

#############
# Libraries #
#############

import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache

import heapq


#############
# Constants #
#############

MOD = 10**9+7
INF = float('inf')

#############
# Functions #
#############

######INPUT######
def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]

#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)

######Combination######
kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret

######Factorization######
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr

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

#############
# Main Code #
#############

X = inputI()

a = 100
count = 0

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

Submission status: Accepted

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


main()

Submission status: Accepted

Solution code:
x = int(input())
now = 100
for i in range(1,100000):
    now = now*1.01//1
    if x<=now:
        break

print(i)

Submission status: Accepted

Solution code:
x=int(input())
tmp=100
for i in range(10000):
  if tmp>=x:
    print(i)
    break
  tmp+=tmp//100

Submission status: Accepted

Solution code:
import sys


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


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


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

    print(cnt)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
# map(int,input().split())
# int(input())
import math
x = int(input())
cnt = 100
nen = 0
while cnt < x:
	cnt = (cnt * 101) //100
	nen += 1
print(nen)

Submission status: Accepted

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

if __name__ == "__main__":
    main()

Submission status: Accepted

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

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

import sys
sys.setrecursionlimit(300000)


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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def main():
    import sys
    sys.setrecursionlimit(10 ** 6)
    input = sys.stdin.readline
    X = int(input())
    Y = 100
    i = 0
    while Y < X:
        i += 1
        Y = int(Y * 1.01)
    print(i)
if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
x = int(input())
tmp = 100
for i in range(1, 10 ** 5):
    tmp = int(tmp * 1.01)
    if tmp >= x:
        print(i)
        break

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
x = int(input())

s = 100
c = 0

while s < x:
    s += s // 100
    c += 1

print(c)