TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N,K = map(int,input().split(" "))
count=0
while(N>0):
    print(N)
    N = N//K
    count+=1
print(count)

N,K = map(int,input().split(" "))
count=0
while(N>0):
    N = N//K
    count+=1
print(count)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):

n,k = map(int,input().split())


def Base_10_to_n(X, n):
    if (int(X/n)):
        return Base_10_to_n(int(X/n), n)+str(X%n)
    return str(X%n)
############################

print(Base_10_to_n(n, k))





n,k = map(int,input().split())


def Base_10_to_n(X, n):
    if (int(X/n)):
        return Base_10_to_n(int(X/n), n)+str(X%n)
    return str(X%n)
############################

a = Base_10_to_n(n, k)

print(len(a))




Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,k = input().split()
k = int(k)
ans = len(int(n,k))
print(ans)

n,k = input().split()
k = int(k)
ans = len(str(int(n,k)))
print(ans)



n,k = input().split()
k  = int(k)

def Base_10_to_n(X, n):
    if (int(X/n)):
        return Base_10_to_n(int(X/n), n)+str(X%n)
    return str(X%n)
ans = len(str(Base_10_to_n(int(n),k)))
print(ans)



Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,k=map(int,input().split())
ans=0
while n!=0:
  if n//k!=0:
    ans=ans+1
  elif n%k!=0:
    ans=ans+1
print(ans)


n,k=map(int,input().split())
ans=0
while n!=0:
  if n//k!=0:
    ans=ans+1
  elif n%k!=0:
    ans=ans+1
  n=n//k
print(ans)

Verdicts: Time Limit Exceeded

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n, k = map(int, input().split())
result = ''
while n != 0:
    result = str(n % k) + result
    n = n // k
result = int(result)
i = 0
while  result / 10 ** i >= 1:
    i += 1
print(i + 1)

n, k = map(int, input().split())
result = ''
while n != 0:
    result = str(n % k) + result
    n = n // k
result = int(result)
i = 0
while  result / 10 ** i >= 1:
    i += 1
print(i)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N,K=map(int,input().split())
J=K
ans=0

while N>J:
    J=J*K
    ans+=1

print(ans)

N,K=map(int,input().split())
J=K
ans=1

while N>=J:
    J=J*K
    ans+=1

print(ans)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
def ten_to_n(X, n):
    i = int(X / n)
    s = str(X % n)
    if (i):
        return Base_10_to_n(i, n) + s
    return s

def solve():
    N, M = map(int, input().split())
    n = Base_10_to_n(N, M)
    return len(n)
 
print(solve())

def ten_to_n(X, n):
    i = X // n
    s = str(X % n)
    if (i):
        return ten_to_n(i, n) + s
    return s

def solve():
    N, M = map(int, input().split())
    return len(str(ten_to_n(N, M)))

print(solve())

Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,m=map(int,input().split()) 
lst_b=[] 
lst_c=[] 
while(True): 
    b=n//m 
    c=n%m 
    lst_b.append(b) 
    lst_c.append(c) 
    n=b 
    	if b==0: 
    		print("".join(map(str,lst_c[::-1]))) 
    		break                       

n,m=map(int,input().split()) 
lst_b=[] 
lst_c=[] 
while(True): 
    b=n//m 
    c=n%m 
    lst_b.append(b) 
    lst_c.append(c) 
    n=b 
    if b==0: 
    	print("".join(map(str,lst_c[::-1]))) 
    	break      

n,m=map(int,input().split()) 
lst_b=[] 
lst_c=[] 
while(True): 
    b=n//m 
    c=n%m 
    lst_b.append(b) 
    lst_c.append(c) 
    n=b 
    if b==0: 
    	print(len("".join(map(str,lst_c[::-1])))) 
    	break      

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
a,b=map(int,input().split())
if b==2:
    a=bin(a)
elif b==8:
    a=oct(a)
elif b==10:
    a=int(a)
print(len(a))

a,b=map(int,input().split())
count=1
while a>=b:
    a=a/b
    count+=1
print(count)

Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,k=map(int,input().split())
i=1
while True:
    if n<k**i:
        print(i)
        break

n,k=map(int,input().split())
i=1
while True:
    if n<k**i:
        print(i)
        break
    i+=1

Verdicts: Time Limit Exceeded

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N, K = map(int,input().split())
i=1
while true:
  if N<K^i:
    print(i)
    break
  else:
    i = i + 1


import math

N, K = map(int,input().split())
if N==1:
  print(1)
else:
  print(math.ceil(math.log(N, K)))

Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n, k = map(int, input().split())
i = 0
while True:
  if n // pow(k, i) == 0:
    print(pow(k, i))
    print(i)
    break
  else:
    i += 1

n, k = map(int, input().split())
i = 0
while True:
  if n // pow(k, i) == 0:
    print(i)
    break
  else:
    i += 1

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
import math as mt
n,k=map(int,input().split())
print(mt.ceil(mt.log(n,k))


x,k=map(int,input().split())
ans=0
while k**ans<=x:
  ans+=1

print(ans)


Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n, k = list(map(int, input().split()))
ans = 0
while True:
    n = n // k
    ans += 1
        if  == 0:
            break
print(ans)

        

n, k = list(map(int, input().split()))
ans = 0
while True:
    l.append(n % k)
    n = n // k
    if n // k == 0:
        l.append(n % k)
        break
ans = len(l)
print(ans)

n, k = list(map(int, input().split()))
ans = 0
# while True:
#     n = n // k
#     ans += 1
#     if n == 0:
#         break
# print(ans)


if k == 10:
    ans = len(str(n))
else:
    l = []
    while True:
    n = n // k
    ans += 1
    if n == 0:
        break
print(ans)


n, k =list(map(int, input().split()))
l = []
while True:
    l.append(n % k)
    n = n // k
    if n == 0:
        l.append(n % k)
        break
ans = len(l)
print(ans)

n, k =list(map(int, input().split()))
l = []
while True:
    l.append(n % k)
    n = n // k
    if n // k == 0:
        #l.append(n % k)
        break
ans = len(l)
print(ans)



n, k =list(map(int, input().split()))
l = []
while True:
    l.append(n % k)
    n = n // k
    if n == 0:
        l.append(n % k)
        break
ans = len(l)
print(ans)


n, k = list(map(int, input().split()))
ans = 0
while True:
    l = []
    l.append(n % k)
    n = n // k
    if n // k == 0:
        l.append(n % k)
        break
ans = len(l)
print(ans)

n, k =list(map(int, input().split()))
l = []
while True:
    l.append(n % k)
    n = n // k
    if n == 0:
        break
ans = len(l)
print(ans)

Verdicts: Runtime Error

Runtime Error

Runtime Error

Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N, K = list(map(int,input().split()))
ans = 1
while N > K:
    N //=K
    ans += 1
print(ans)

N, K = list(map(int,input().split()))
ans = 0
while N > 0:
    N //=K
    ans += 1
print(ans)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
i = list(map(int, input().split()))
j=1
while i[0]<i[1]**j:
  j+=1
print(j)

i= list(map(int, input().split()))
j=1
while i[0]>=i[1]**j:
  j+=1
print(j)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n=int(input())
k=int(input())
cnt = 0

while(n > 0):
  n /= k
  cnt += 1

print(cnt)

n,k=map(int,input().split())

cnt = 0

while(n > 0):
  n //= int(k)
  cnt += 1
  int(n)

print(cnt)

Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,k = map(int,input().split())
a = []
while n//k != 0:
  a.append(n%k)
  n = n//k
  
  if n//k ==0:
    a.append(n%k)
len(a)

n,k = map(int,input().split())
a = []
while n//k != 0:
  a.append(n%k)
  n = n//k
  
  if n//k ==0:
    a.append(n%k)
len(a)

n,k = map(int,input().split())
a = []
while n//k != 0:
  a.append(n%k)
  n = n//k
  
  if n//k ==0:
    a.append(n%k)
    a.reverse()
len(a)

n,k = map(int,input().split())
a = []
if n//k == 0:
  print(1)

else:
  while n//k != 0:
    a.append(n%k)
    n = n//k
  
    if n//k ==0:
      a.append(n%k)
  a.reverse()
  
  print(len(a))

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
def calculate_num(m, n):
  integer = m
  base = n
  result = ''
  while integer > 0:
    result += str(integer%base) + result
    integer = integer//base
    print(integer)
  return result

def main():
  num = input()
  num_list = num.split()
  number = int(num_list[0])
  base = int(num_list[1])
  result = calculate_num(number, base)
  print(int(result))
main()

def calculate_num(m, n):
  integer = m
  base = n
  result = ''
  digit = 0
  while integer > 0:
    result += str(integer%base) + result
    integer = integer//base
    digit = len(result)
  return digit

def main():
  num = input()
  num_list = num.split()
  number = int(num_list[0])
  base = int(num_list[1])
  result = calculate_num(number, base)
  print(result)
main()

def calculate_num(m, n):
  integer = m
  base = n
  result = ''
  digit = 0
  while integer > 0:
    result += str(integer%base)
    integer = integer//base
    digit = len(result)
  return digit

def main():
  num = input()
  num_list = num.split()
  number = int(num_list[0])
  base = int(num_list[1])
  result = calculate_num(number, base)
  print(result)
main()

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):

import sys
import math
N,K = map(int,input().split())

if not ( 1 <= N <= 10**9 and 2 <= K <= 10 ): sys.exit()

count = 0
a = N
while a >= K:
    a = a // K
    print(a)
    count += 1
print(count+1)


import sys
N,K = map(int,input().split())

if not ( 1 <= N <= 10**9 and 2 <= K <= 10 ): sys.exit()

count = 0
a = N
while a >= K:
    a = a // K
    count += 1
print(count+1)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
# Digits
N, K = map(int, input().split())
div = N // K
digits = []
while div > K:
    div = N // K
    digits.append(str(N % K))
    N   = div
digits.append(str(N % K))
if N // K != 0:
    digits.append(str(N // K))

ans = ''.join(digits[::-1])
print(ans)

# Digits
N, K = map(int, input().split())
div = N // K
digits = []
while div > K:
    div = N // K
    digits.append(str(N % K))
    N   = div
digits.append(str(N % K))
if N // K != 0:
    digits.append(str(N // K))
ans = len(digits)
print(ans)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
import sys
import math
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**8)
INF = float('inf')
MOD = 10**9+7


def main():
  N, K = map(int, readline().split())
  ans = math.log(1,2)
  print(math.ceil(ans))
  
  
  
if __name__ == '__main__':
  main()

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


def main():
  N, K = map(int, readline().split())
  if N<K:
    ans = 1
  else:
    ans = math.ceil(math.log(N,K))
  print(ans)
  
  
  
if __name__ == '__main__':
  main()

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N, R = map(int, input().split())
if N >= 10:
    ans = R
else:
    ans = R + 100 * (10 - N)
    
print(ans)   

N, K = map(int, input().split())

i = 0
while K ** i <= N:
    ans = i + 1
    i += 1
    
print(ans)    

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,sin=map(int,input().split(' '))
while n>=sin:
    ls.append(n%sin)
    n=n//sin
ls.append(n)
print(len(ls))

n,sin=map(int,input().split(' '))
ls=[]
while n>=sin:
    ls.append(n%sin)
    n=n//sin
ls.append(n)

print(len(ls))

Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N,K = map(int, input().split())
i = 1
while K**i =< N:
    i+=1
else:
    print(i)

N,K = map(int, input().split())
i = 1
while K**i <= N:
    i+=1
else:
    print(i)

Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N,K = map(int,input().split())
c = 1
s = 1
while(s<N):
    s *= K
    c += 1
print(c)

N,K = map(int,input().split())
c = 0
s = 1
while(s<=N):
    s *= K
    c += 1
print(c)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,k = map(int,input().split())
count = 1
while n > 0:
  n //= k 
  count += 1
print(count)

n,k = map(int,input().split())
count = 0
while n > 0:
  n //= k 
  count += 1
print(count)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
def base10to(n, b):
　  if (int(n/b)):
　　    return base10to(int(n/b), b) + str(n%b)
    return str(n%b)
N, K=map(int, input().split())
print(len(base10to(N,K)))

def base10to(n, b):
　  if (int(n/b)):
　　    return base10to(int(n/b), b) + str(n%b)
    else: 
        return str(n%b)
N, K=map(int, input().split())
x = base10to(N,K)
print(len(x))

def base10to(n, b):
　  if (int(n/b)):
　　    return base10to(int(n/b), b) + str(n%b)
    return str(n%b)
N, K=map(int, input().split())
x = base10to(N,K)
print(len(x))

def base10to(n, b):
    if (int(n/b)):
        return base10to(int(n/b), b) + str(n%b)
    return str(n%b)
N, K=map(int, input().split())
print(len(base10to(N,K)))

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N,K=map(int,input().split())
hey=N
ans=1
while hey//K >= K:
    ans += 1
    hey = hey//K
print(ans)

N,K=map(int,input().split())
hey=N
ans=1
while hey >= K:
    ans += 1
    hey = hey//K
print(ans)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n, k = [int(i) for i in input().split()]
def Base_10_to_n(X, n):
    X_dumy = X
    out = ''
    while X_dumy>0:
        out = str(X_dumy%n)+out
        X_dumy = int(X_dumy/n)
    return out
print(Base_10_to_n(n, k))

n, k = [int(i) for i in input().split()]
def Base_10_to_n(X, n):
    if (int(X/n)):
        return Base_10_to_n(int(X/n), n)+str(X%n)
    return str(X%n)
print(Base_10_to_n(n, k))


n, k = [int(i) for i in input().split()]
def decNbin(t, n):
  a = []
  while t!= 0:
    a.append(t % n)
    t  = t // n
  a.reverse()
  return a
"".join(map(str, decNbin(n, k)))

n, k = [int(i) for i in input().split()]
def decNbin(t, n):
  a = []
  while t!= 0:
    a.append(t % n)
    t  = t // n
  a.reverse()
  return a
print(len(str("".join(map(str, decNbin(n, k))))))


Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
import math
N,K = map(int,input().split())
Ans = (math.log(K,N) +1)
print(Ans)

N,K = map(int,input().split())
for i in range(10**9):
  print(K**i)
  if K**i <= N < K**(i+1):
    print(i+1)
    break

import math
N,K = map(int,input().split())
Ans = (int(math.log(N,K)) +1)
print(Ans)

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,k=map(int,input().split())
for i in range(10**10**10**10**10):
  if k**i>n:
    print(i)
    exit()

n,k=map(int,input().split())
for i in range(10**10):
  if k**i>n:
    print(i)
    exit()


Verdicts: Time Limit Exceeded

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,k =list(map(int,input().split()))
A=0

while True:
    n =n//k
    A+=1
    if n//k==0:
        break
print(A)

n,k =list(map(int,input().split()))
A=0

while True:
    n =n//k
    A+=1
    if n==0:
        break
print(A)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n, k = map(int, input().split())
c = 0
while(n != 0):
  n //= k
  print(n)
  c += 1
print(c)

n, k = map(int, input().split())
c = 0
while(n != 0):
  n //= k
  c += 1
print(c)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,k=map(int,input().split())
i=1
while True:
    if n<(k**(i-1)):
        print(i)
        break
    else:
        i=i+1

n,k=map(int,input().split())
i=1
while True:
    if n<(k**(i-1)):
        print(i-1)
        break
    else:
        i=i+1

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
def Digits(N, K):
  if not N:
    return 1
  digits = 0
  while not N:
    N = N // K
    digits += 1
  return digits
 
N, K = map(int, input().split())
print (Digits(N, K))

def Digits(N, K):
  if N:
    return 1
  digits = 0
  while N:
    N = N // K
    digits += 1
  return digits

N, K = map(int, input().split())
print (Digits(N, K))

def Digits(N, K):
  if not N:
    return 1
  digits = 0
  while N:
    N = N // K
    digits += 1
  return digits
 
N, K = map(int, input().split())
print (Digits(N, K))


Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
def main():
    n, k = map(int, input().split())
    cnt = 0
    i = 1
    
    while n >= i:
        print(i)
        i *= k
        cnt += 1
    print(cnt)

if __name__ == '__main__':
    main()

def main():
    n, k = map(int, input().split())
    cnt = 0
    i = 1
    
    while n >= i:
        i *= k
        cnt += 1
    print(cnt)

if __name__ == '__main__':
    main()

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
counter = 0
n, k = map(int, input().split())
for i in range(100):
  if k ** i >= n:
    counter = i + 1
print(counter)

counter = 0
n, k = map(int, input().split())
for i in range(100):
  if k ** i <= n:
    counter = i + 1
  else:
    break
print(counter)


Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
nt,kt = input().split()
n = int(nt)
k = int(kt)
i = 1
while n > (k ** i):
  i = i+1
    
print(i +1)


nt,kt = input().split()
n = int(nt)
k = int(kt)
i = 1
while n >= (k ** i):
  i = i+1
    
print(i)


Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n, k = map(int, input().split())
res = 0
while n >= k:
  res += 1
  n //= k
  print(res+1)

n, k = map(int, input().split())
res = 0
while n >= k:
  res += 1
  n //= k
print(res+1)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
i = 1
while n >= k**i:
    i += 1

print(i)

n,k = map(int, input().split())
x = 0
while n:
  n //= k
  x += 1
print(x)

Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
l=input().split()
N=int(l[0])
K=int(l[1])
cnt=0
a=N

while True:
  a=a/K
  cnt+=1
  if a==0:break

print(a)

import math

l=input().split()
N=int(l[0])
K=int(l[1])
cnt=0
a=N

while True:
    a=math.floor(a/K)
    cnt+=1
    if a==0:break

print(cnt)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,k = map(int, input().split())

ans = 0

while n > 0:
  n /= k
  ans += 1
  
print(ans)


n,k = map(str, input().split())
k = int(k)
num = 0

for i in range(0, len(n)):
  sum += int(n[i]) * k^(len(n)-i)
  
print(len(str(sum)))

n,k = map(str, input().split())
k = int(k)
num = 0

for i in range(0, len(n)):
  num += int(n[i]) * (len(n)-i) * k^(len(n)-i)
  
print(len(str(num)))


n,k = map(int, input().split())

ans = 0

while n > 0:
  n /= k
  n = int(n)
  ans += 1
  
print(ans)


Verdicts: Wrong Answer

Runtime Error

Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n, k = map(int, input().split())
count = 0
while n >=0:
    n //= k
    count += 1
print(count)

n, k = map(int, input().split())
count = 0
while n >0:
    n //= k
    count += 1
print(count)

Verdicts: Time Limit Exceeded

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,k=map(int,input().split())
a=1
while n > k:
  n//=k
  a+=1
print(a)

n,k=map(int,input().split())
i = 1
w = k
while w < n:
  w *= k
  i += 1
print(i+1)

n, k = map(int, input().split())
ans=0
while n > 0:
  n//=k
  ans+=1
  
print(ans)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n, k = map(int,input().split())
count = 0
while True:
  n = n//k
  count += 1
  print(n)
  if n <1:
    print(n)
    break
    
    
print(count)

n, k = map(int,input().split())
count = 0
while True:
  n = n//k
  count += 1
  if n <1:
    break
    
    
print(count)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
# input
N, K = map(int, input().split())

i = 1
while N <= K ** i:
    if N <= K ** i:
        i += 1

print(i)

# input
N, K = map(int, input().split())

i = 2
while N > K ** i:
    if N <=  K ** i:
        i += 1

print(i)

# input
N, K = map(int, input().split())

i = 1
while N >= K ** i:
    if N >= K ** i:
        i += 1

print(i)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N, K = map(int, input().split())
def transform(X, n):
    print(int(X/n))
    if (int(X/n)):
        return transform(int(X/n), n)+str(X%n)
    return str(X%n)

print(len(transform(N, K)))


N, K = map(int, input().split())
def transform(X, n):
    if (int(X/n)):
        return transform(int(X/n), n)+str(X%n)
    return str(X%n)

print(len(transform(N, K)))


Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,k = map(int,input().split())
i = 0
while n > 0:
    n = n%k
    i += 1
print(i)

n,k = map(int,input().split())
i = 1
while n//k > 0:
    n //= k
    i +=1
print(i)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
def from_10_to_n(x, n):
  tmp = x
  out = ''
  while tmp > 0:
    out = str(x % n) + out
    tmp = tmp // n
  return out

N, K = map(int, input().split())
N = from_10_to_n(x, n)
print(len(N))

N, K = map(int, input().split())




ans = 0
while N > 0:
  N //= K
  ans += 1

print(ans)

Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
,k = map(int,input().split())
a = 1
while k**a < n:
    a += 1

print(a)

n,k = map(int,input().split())
a = 1
while k**a <= n:
    a += 1

print(a)

Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N,K=map(int,input().split())
i=0
while N>=k**i:
    i+=1
print(i)

N,K=map(int,input().split())
i=0
while N>K=**i:
    i+=1
print(i)

N,K=map(int,input().split())
i=0
while N>=K**i:
    i+=1
print(i)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,k = map(int, input().split())
# n,k = map(int, "282475249 7".split())

isFlg = False
i=1
while True:
    tmp = k **i

    if n <= tmp:
        isFlg = True

    i+=1

    if isFlg:
        break

print(i)




n,k = map(int, input().split())

isFlg = False
i=1
while True:
    tmp = k **i

    if n < tmp:
        isFlg = True


    if isFlg:
        break

    i+=1


print(i)




Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
#include<bits/stdc++.h>
using namespace std;
typedef long long int INT;

INT pow(int n,int k)
{
    INT a=1;
    for (int i=1;i<=k;i++){
        a*=n;
    }
    return a;
}

int main()
{
    INT n;
    int k;
    cin>>n>>k;
    int i=0;
    while(1){
        if(n<pow(k,i)){
            cout<<i<<endl;
            break;
        }
        ++i;
    }
}

n,k=map(int,input().split())
cnt=0
i=1
 
while True:
    p=n//k**i
    if p==0:
        print(i)
        break
    else:
        i+=1

Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n, k = map(int, input().split())
ans = []
while n > k :
  n = n // k
  mod = n % k
  ans.append(str(ans))
print("".join(ans))


n, k = map(int, input().split())
ans = []
while n >= k :
  n = n // k
  mod = n % k
  ans.append(mod)
ans.append(n)  
print(len(ans))


Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N, K = map(int, input().split())
ans = ''
while N >= K:
    ans = str(N % K) + ans
    N  = N // K
    print(ans)
ans = str(N) + ans
print(len(ans))

N, K = map(int, input().split())
ans = ''
while N >= K:
    ans = str(N % K) + ans
    N  = N // K
ans = str(N) + ans
print(len(ans))

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N, K = map(int, input().split())
cnt = 0
while True:
  cnt += 1
  N = N//K
  if N != 0:
print(cnt) 

N, K = map(int, input().split())
cnt = 0
while True:
  cnt += 1
  N = N//K
  if N == 0:
    break
print(cnt) 

Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,k = map(int, input().split())
count = 0
while n > 0:
    n = n / k
    count += 1 
print(count+1)

n,k = map(int, input().split())
count = 0
while n > 0:
    n //= k
    count += 1 
print(count)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N,K=input().split()
C=0
while(int(N)>=int(K)):
  C=C+1
  N=int(N)-int(K)**C
print(C)

N,K=input().split()
C=0
while(int(N)>=int(K)):
  N=int(N)//int(K)
  C=C+1
print(C+1)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
import sys
n,k=map(int,input().split())
for i in range(length.n):
  if k**i<=n and n<k**(i+1):
    print(i+1)
    sys.exit()
  

import sys
n,k=map(int,input().split())
for i in range(n):
  if k**i<=n and n<k**(i+1):
    print(i+1)
    sys.exit()
  

Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n, r = map(int, input().split())
i = r
c = 1
while i <= n:
	i *= r
    c += 1
print(c)

n, r = map(int, input().split())
i = r
c = 1
while i <= n:
	i *= r
	c += 1
print(c)

Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
import math
n,k=map(int,input().split())
print(int(math.log(n,k)))

import math
n,k=map(int,input().split())
print(int(math.log(n,k))+1)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,k=map(int,input().split())
sum=0
while n>=1:
  n=n/k
  sum+=1
  
return sum


n,k=map(int,input().split())
sum=0
while n>1:
  n=n/k
  sum+=1
  
return sum

n,k=map(int,input().split())
sum=0
while n>=1:
  n=n/k
  sum+=1
  
print sum


n,k=map(int,input().split())
count=1
while n>=k:
  n=n/k
  count+=1
print(count)


Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N = int(input())
X = list(map(int, input().split()))
ans = 100 ** 100

for p in range(1, 101):
	now = 0
	for x in X:
		now += (p - x) ** 2
	ans = min(ans, now)
print(ans)


N, K = list(map(int, input().split()))
ans = 0
while N > 0:
    N //= K
    ans += 1
print(ans)

Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n = int(input())
k = int(input())
i = 0
while True:
   if n < k**(i+1):
     print(i + 1)
     break
   i += 1

n,k = map(int,input().split())

i = 0
while True:
   if n < k**(i+1):
     print(i + 1)
     break
   i += 1



Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
import math

N, K = map(int, input().split())
P = math.log(N, K)
Q = math.floor(P)

print(Q)

import math
 
N, K = map(int, input().split())
P = math.log(N, K)
Q = math.floor(P)
 
print(Q + 1)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
import sys
input = sys.stdin.readline

N, K = map(int, input().split())

d = 1
while N:
    N //= 2
    d += 1

print(d)


import sys
input = sys.stdin.readline

N, K = map(int, input().split())

d = 0
while N:
    N //= K
    d += 1

print(d)


Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,k=map(int,input().split())
cnt=0
while n>0:
    n=n/k
    cnt+=1
print(cnt)

def convert(n, k):
    if (int(n/k)):
        return convert(int(n/k), k)+str(n%k)
    return str(n%k)
n,k=map(int,input().split())
print(len(Base_10_to_n(n,k)))

n,k=map(int,input().split())
cnt=0
while n>0:
    n=n//k
    cnt+=1
print(cnt)

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n, k = map(int, input().split())
ans = 0
while True:
    if n // (k ** ans) == 0:
        break
    a += 1
print(ans)

n, k = map(int, input().split())
ans = 0
while True:
    if n // (k ** ans) == 0:
        break
    ans += 1
print(ans)

Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,k=map(int,input().split())
ans=0
while(n>1):
  n//=k; ans+=1
print(ans)

n,k=map(int,input().split())
ans=0
while(n):
  n//=k; ans+=1
print(ans)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
imports sys
l = sys.stdin.readline()
n, k = map(int, l.split())
if n == 0:
  print(1)
  sys.exit(0)
count = 0
while n > 0:
  	n /= k
    count += 1
print(count)

import sys
l = sys.stdin.readline()
n, k = map(int, l.split())
if n == 0:
  print(1)
  sys.exit(0)
count = 0
while n > 0:
    n //= k
    count += 1
print(count)

Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,k = list(map(int, input().split()))
ans = ""

while n != 0:
    ans = str(n%k) + ans
    n //= k

print(ans)

n,k = list(map(int, input().split()))
ans = ""

while n != 0:
    ans = str(n%k) + ans
    n //= k

print(len(ans))


Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
rc = list(map(int, input().split()))

digit = 1
while src[1] ** digit - 1 < src[0]:
    digit += 1

print(digit)

src = list(map(int, input().split()))

digit = 1
while src[1] ** digit - 1 < src[0]:
    digit += 1

print(digit)


Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,k=map(int,input().split())
ans=0
while(n>0)
    n=n//k
    ans+=1
print(ans)

n,k=map(int,input().split())
ans=0
while n>=0:
    n//k
    ans+=1
print(ans)

n,k=map(int,input().split())
ans=0
while(n>0):
    n=n//k
    ans+=1
print(ans)

Verdicts: Runtime Error

Time Limit Exceeded

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N, K = map(int, input().split())
ans = 0
while N > 0:
  N /= K
  ans += 1
print(ans)

N, K = map(int, input().split())
ans = 0
while N > 0:
  N //= K
  ans += 1
print(ans)


Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n, k = map(int, input().split())
count == 0
while n >= k:
  n = n // k
  count += 1
print(count)

n, k = map(int, input().split())
count = 0
while n >= k:
  n = n // k
  count += 1
print(count+1)


Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N, R = map(int, input().split())
q = N/K
num = 0
while q >0:
  q = q / K**num
  num = num + 1
print(num)

N, K = map(int, input().split())
num = 0
while q > 0:
  num = num + 1
  q = N // (K**num)
print(num)

N, K = map(int, input().split())
q = N/K
num = 0
while q > 0:
  q = q // (K**num)
  num = num + 1
print(num)

N, K = map(int, input().split())
q = N/K
num = 0
while q >0:
  q = q / (K**num)
  num = num + 1
print(num)

N, K = map(int, input().split())
num = 0
while q > 0:
  num = num + 1
  q = N // (K**num)  
print(num+1)

N, R = map(int, input().split())
q = N/K
num = 0
while q >0:
  q = q / (K**num)
  num = num + 1
print(num)

N, K = map(int, input().split())
num = 0
while q > 0:
  num = num + 1
  q = N // (K**num)
A = num + 1
print(A)

N, K = map(int, input().split())
num = 0
q = N
while q > 0:
	num = num + 1
	q = N // (K**num)
print(num)

Verdicts: Runtime Error

Runtime Error

Wrong Answer

Wrong Answer

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
from sys import stdin
N,K = [int(x) for x in stdin.readline().rstrip().split()]
ans = 0
for k in range(1000000):
    N -= (K**k)
    if N < 0:
        break
    ans += 1
    
print(ans)

from sys import stdin
N,K = [int(x) for x in stdin.readline().rstrip().split()]
ans = 0
for k in range(10000000):
    if N < K**k:
        break
    
print(k)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n, k = map(int, input().split())



#         print(i)
#         break

temp = 1
cnt = 0
while n > temp - 1:
    temp *= k
    print(temp)
    cnt += 1
print(cnt)


n, k = map(int, input().split())



#         print(i)
#         break

temp = 1
cnt = 0
while n > temp - 1:
    temp *= k
    # print(temp)
    cnt += 1
print(cnt)


Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using P = pair<ll, ll>;
using Graph = vector<vector<ll>>;
#define rep(i, n) for(ll i=0;i<(ll)(n);i++)
#define rep2(i, m, n) for(ll i=m;i<(ll)(n);i++)
#define rrep(i, n, m) for(ll i=n;i>=(ll)(m);i--)
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const int ddx[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const int ddy[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll MOD = 1000000007;
const ll INF = 1000000000000000000L;
#ifdef __DEBUG

/**
 * For DEBUG
 * https://github.com/ta7uw/cpp-pyprint
 */
#include "cpp-pyprint/pyprint.h"

#endif

void Main() {
    ll N, K;
    cin >> N >> K;
    ll ans = 0;
    ll tmp = 0;
    while (pow(K, tmp) <= N) {
        tmp++;
    }
    rep2(i, 1, tmp + 1) {
        if (pow(K, i - 1) <= N && N < pow(K, i)) {
            ans = max(ans, i);
        }
    }
    cout << ans << '\n';
}

int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(15);
    Main();
    return 0;
}


N, K = map(int, input().split())

ans = -1
for i in range(1, 40):
    if K ** (i - 1) <= N < K ** i:
        ans = i

print(ans)


Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):

N,K = map(int,input("入力：").split())
q, mod = divmod(N,K)
mod_list = [mod]
while True:
    q , mod =divmod(q,K)
    mod_list.append(mod)
    if q <=0 :
        break

n_ary = int("".join(map(str,mod_list[::-1])))
print(len(str(n_ary)))


N,K = map(int,input().split())
q, mod = divmod(N,K)
mod_list = [mod]
while True:
    q , mod =divmod(q,K)
    mod_list.append(mod)
    if q <=0 :
        break

n_ary = int("".join(map(str,mod_list[::-1])))
print(len(str(n_ary)))

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n, k = map(int, input().split())
ans = 0

def base_10_to_n(x, n):
    if int(x / n):
        return base_10_to_n(int(x / n), n) + str(X % n)
    return str(x % n)

print(len(str(base_10_to_n(n, k))))

n, k = map(int, input().split())
ans = 0

def base_10_to_n(x, n):
    if int(x / n):
        return base_10_to_n(int(x / n), n) + str(x % n)
    return str(x % n)

print(len(str(base_10_to_n(n, k))))

Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N,K=map(int,input().split())
i=0
while N>K**i:
  i=i+1
else:
  print(i+1)

N,K=map(int,input().split())
i=0
while N>=K**i:
  i=i+1
else:
  print(i)


Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N, K = map(int, input().split())
N_ = N
num = 1
while N > K:
    N = N//K
    num +=1

list = []
print(num)


for i in range(num, -1, -1):
    n = str(N_//(K**i))
    N_ = N_ % (K**i)
    # print(N_, n)
    list.append(n)

print(len(list))



N, K = map(int, input().split())
N_ = N
num = 1
while N > K:
    N = N//K
    num +=1

list = []

for i in range(num, -1, -1):
    n = str(N_//(K**i))
    N_ = N_ % (K**i)
    # print(N_, n)
    list.append(n)


while list[0] == "0":
    list.remove("0")

print(len(list))



Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N, K = map(int, input().split())
cout = 1
for i in ranga(N):
    N = N//K
    cout += 1
    if N<K:
        break
print(cout)

N, K = map(int, input().split())
cout = 0
for i in range(N):
    N = N//K
    cout += 1
    if N<K:
        break
print(cout)

N, K = map(int, input().split())
cout = 1
for i in range(N):
    if N<K:
        break
    N = N//K
    cout += 1

print(cout)

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
import string
numbers = "0123456789"
alphabets = string.ascii_letters 
characters = numbers + alphabets
NK=list(map(int,input().split()))
n=NK[0]
k=NK[1]
result = ''
while n>=k:
    idx=n%k
    result=characters[idx]+result
    n=int(n/k)
    idx=n%k
    result=characters[idx]+result
#     return result
print(result)

N,K=map(int,input().split())
def Base_10_to_n(N,K):
    X_dumy = N
    out = ''
    while X_dumy>0:
        out = str(X_dumy%K)+out
        X_dumy = int(X_dumy/K)
    return out
print(len(str(Base_10_to_n(N,K))))

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n, k = map(int, input().split())
ans = 0

for i in range(n):
    t = k ** i
    if n > t:
        ans += 1
        if n % t == 0:
            ans += 1
    else:
        break
print(ans + 0)


import math
n, k = map(int, input().split())

ans = int(math.log(n, k))

print(ans+1)


Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N,K=map(int,input().split())
cnt=0
while N//K>=1:
        cnt += 1
print(cnt+1)

N,K=map(int,input().split())
cnt=0
while N//K>=1:
        cnt += 1
print(cnt)

N,K=map(int,input().split())
cnt=0
for i in range(1,100):
        if N/(K**i)>=1:
                cnt += 1
print(cnt+1)

Verdicts: Time Limit Exceeded

Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N, K = map(int,input().split())
 
ans = 1
 
 while N >= K:
    N = N // K
    ans += 1
    
print(ans)

n,k=map(int,input().split())
i=0
while (n>1):
    n/=k
    i+=1
    print(n)
print(i)

n,k=map(int,input().split())
i=0
while (n>0):
    n/=k
    i+=1
print(i)

N, K = map(int,input().split())
 
ans = 1

while N >= K:
    N = N // K
    ans += 1
    
print(ans)

Verdicts: Runtime Error

Wrong Answer

Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,k = map(int,input().split())
ans = 0
while int(n / k) != 0:
  ans += 1
  n = int(n / k)
print(ans)

n,k = map(int,input().split())
ans = 1
while n != 0:
  n = int(n / k)
  ans += 1
print(ans)

n,k = map(int,input().split())
ans = 0
while n != 0:
  n = int(n / k)
  ans += 1
print(ans)


Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N,K = map(int,input().split())
Count=0
while N > 0:
  N = int(N/K)
  print(N)
  Count=Count+1
print(Count)

N,K = map(int,input().split())
Count=0
while N > 0:
  N = int(N/K)
  Count=Count+1
print(Count)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
import math

def finddigit(n, b):
    dig = (math.floor(math.log(n)/math.log(b))+1)
    print(dig)

finddigit(n,b)


import math

def finddigit(n, b):
    dig = (math.floor(math.log(n)/math.log(b))+1)
    print(dig)

n,b = map(int,input().split())
finddigit(n,b)


Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N, K = map(int,input().split())

counter = 0
while N >= K:
    N = N/K
    counter = counter + 1

print(counter)

N, K = map(int,input().split())

counter = 1
while N >= K:
    N = N/K
    counter = counter + 1

print(counter)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n, k = map(int, input().split())
print(n // k + 1)

n, k = map(int, input().split())
i = 0
while n:
  n //= k
  i += 1
print(i)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n, k = map(int, input().split())
res = 0
while n > k:
  res += 1
  n //= k
print(res+1)

n, k = map(int, input().split())
res = 0
while n >= k:
  res += 1
  n //= k
print(res+1)


Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,k=map(int,input())
ans=0
while n>0:
  ans+=1
  n=n//k
print(ans)

n,k=map(int,input().split())
ans=0
while n>0:
  ans+=1
  n=n//k
print(ans)


Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
# -*- coding: utf-8 -*-

n, k = map(int, input().split())

res = 0
while n > 0:
    res += 1
    n //= k
    print(res, n, k)
print(res)

# -*- coding: utf-8 -*-

n, k = map(int, input().split())

res = 0
while n > 0:
    res += 1
    n //= k
print(res)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N,K=map(int,input().split())
X=0
cnt=0
i=0

while X<N:
    X=X+K**i
    print(X)
    i=i+1
    cnt=cnt+1

print(i)

N,K=map(int,input().split())
X=0
i=0
while X<N:
    X=X+(K-1)*K**i
    i=i+1
print(i)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n, k = map(int, input().split())

count = 1
while True:
    if n / k >= 1:
        n  = int(n / k)
        print(n)
        count += 1
    else:
        break

print(count)

n, k = map(int, input().split())

count = 1
while True:
    if n / k >= 1:
        n  = int(n / k)
        count += 1
    else:
        break

print(count)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N, K = [int(i) for i in input().split()]
print(int(math.floor(math.log(float(N)/math.pow(K,2), K))) + 1 + 2)

import math

N, K = [int(i) for i in input().split()]
print(int(math.floor(math.log(float(N)/math.pow(K,2), K))) + 1 + 2)

Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
n,k=map(int,input().split())
print(n,k)
ans=1
f=0
while ans < n:
    ans*=k
    f+=1
print(f)

n,k=map(int,input().split())
ans=1
f=0
while ans < n+1:
    ans*=k
    f+=1
print(f)

Verdicts: Wrong Answer

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
# coding: utf-8
n, k = map(int, input().split())
ans = 1
while n > k:
    n = n // k
    ans = ans + 1
print(ans)


# coding: utf-8
import math
n, k = map(int, input().split())
if n % k
print(int(math.log(n, k)) + 1)


# coding: utf-8
import math
n, k = map(int, input().split())
print(int(math.log(n, k)) + 1)


Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
i = input().split()
N = int(i[0])
K = int(i[1])
log = 0

log = math.log(N,K)
if int(log) != log:
  log += 1

print(log)

import math
 
i = input().split()
N = int(i[0])
K = int(i[1])
result = 0
 
result = math.log(N, K)
result = 1 + int(result)

 
print(result)

Verdicts: Runtime Error

Accepted
Problem: Given is an integer N. Find the number of digits that N has in base K.

Submission attempts (in order):
N, K = map(int, input().split())
T = 0

while T != 0:
  N = N // K
  T += 1
  
print(T)

N, K = map(int, input().split())
T = 0
 
while N > 0:
  N = N // K
  T += 1
  
print(T)

Verdicts: Wrong Answer

Accepted