Problem:


Score : 300 points

Problem Statement

1000000000000001 dogs suddenly appeared under the roof of Roger's house, all of which he decided to keep. The dogs had been numbered 1 through 1000000000000001, but he gave them new names, as follows:

the dogs numbered 1,2,\cdots,26 were respectively given the names a, b, ..., z;

the dogs numbered 27,28,29,\cdots,701,702  were respectively given the names aa, ab, ac, ..., zy, zz;

the dogs numbered 703,704,705,\cdots,18277,18278  were respectively given the names aaa, aab, aac, ..., zzy, zzz;

the dogs numbered 18279,18280,18281,\cdots,475253,475254  were respectively given the names aaaa, aaab, aaac, ..., zzzy, zzzz;

the dogs numbered 475255,475256,\cdots  were respectively given the names aaaaa, aaaab, ...;

and so on.

To sum it up, the dogs numbered 1, 2, \cdots were respectively given the following names:

a, b, ..., z, aa, ab, ..., az, ba, bb, ..., bz, ..., za, zb, ..., zz, aaa, aab, ..., aaz, aba, abb, ..., abz, ..., zzz, aaaa, ...

Now, Roger asks you:

"What is the name for the dog numbered N?"

Constraints

N is an integer.

 1 \leq N \leq 1000000000000001

Input

Input is given from Standard Input in the following format:

N

Output

Print the answer to Roger's question as a string consisting of lowercase English letters.

Sample Input 1

2

Sample Output 1

b

Sample Input 2

27

Sample Output 2

aa

Sample Input 3

123456789

Sample Output 3

jjddja



Sample input:
2


Sample output:
b

Submission status: Wrong Answer

Solution code:
N = int(input())
N_ = N
b = 26
cnt = 1
while(N_>b):
    N_ -= b
    b*=26
    cnt+=1
ans = ''
for c in range(cnt):
    d = cnt-c-1
    a = N // (26**d)
    N %= (26**d)
    chr_s = chr(ord('a')-1+a)
    ans += chr_s
print (ans)

Submission status: Wrong Answer

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

    aord = ord('a')
    ans = ''
    
    while N:
        N, Nmod = divmod(N, 26)
        if Nmod:
            ans = chr(aord + Nmod - 1) + ans

    print(ans)


if __name__ == '__main__':
	main()

exit()

Submission status: Wrong Answer

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

N = int(input())
M = 26
digit = 0

for d in range(12):
    if N <= M ** d:
        digit = d - 1
        break
    N -= M ** d

name = ""

for i in range(digit + 1):
    name += chr(ord("a") + (N % M))
    N //= M

print(name[::-1])

Submission status: Wrong Answer

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

N = int(input())
M = 26
digit = 0

for d in range(11):
    if N <= M ** d:
        digit = d - 1
        break
    N -= M ** d

name = ""

for i in range(digit + 1):
    name += chr(ord("a") + (N % M))
    N //= M

print(name[::-1])

Submission status: Wrong Answer

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

N = int(input())
M = 26
digit = 0

for d in range(11):
    if N <= M ** d:
        digit = d - 1
        break
    N -= M ** d

name = ""

for i in range(digit + 1):
    name += chr(ord("a") + (N % M))
    N //= M

print(name)

Submission status: Wrong Answer

Solution code:
import math
N = int(input())
num = int(math.log(N,26))
div = []
ans = []
sum = 0
alpha = list('abcdefghijklmnopqrstuvwxyz')

for i in range(num):
    sum += 26**i

residual = N - sum
for i in reversed(range(num+1)):
    if i == num:
        div.append(residual // 26**i)
        residual = residual % 26**i
    elif i != 0:
        div.append(residual // 26**i+1)
        residual = residual % 26**i
    else:
        div.append(residual+1)

for k in div:
    ans.append(alpha[k-1])
print(''.join(ans))

Submission status: Wrong Answer

Solution code:
import math

def main():
    a = int(input())
    ans = ''

    for i in range(1, 99):
        if a <= 26 ** 1:
            a -= 1
            for j in range(i):
                ans += chr(ord('a') + a % 26)
                a //= 26
            break
        else:
            a -= 26 ** i
    print(ans[::-1])


if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
n=int(input())
ans=""
for l in range(1,15):
  if n<26**l:
    n-=1
    for j in range(l):
      ans+=chr(ord('a')+n%26)
      n//=26
    break
  else:
    n-=26**l
    
print(ans[::-1])

Submission status: Wrong Answer

Solution code:
n = int(input())

an =[]
for i in range(11):
    if 26**(10-i)<=n and i<10:
        wk = n//26**(10-i)
        n=n%26**(10-i)
        an.append(chr(wk%26+96))
if n==0:
    an[:1]='z'
else:
    an.append(chr(n+96))
        
print(''.join(an))

Submission status: Wrong Answer

Solution code:
def nod(n) :
    i = 1
    while n > 26 ** i :
        n = n - 26 ** i
        i += 1
    return i
 
n = int(input())
i = nod(n)
demo = [26 ** j for j in range(12)]
demo1 = []
k = 0
for j in demo :
    k += j
    demo1.append(k)
n = n - demo1[i - 1] + 1
i -= 1
ans = []
tester = False
while i >= 0 :
    if n % 26 == 0 and tester == False :
        k = n // (26 ** i)
        k -= 1
        tester = True
    else :
        k = n // (26 ** i)
    n -= (26 ** i) * k
    if i > 0 :
        ans.append(chr(96 + k + 1))
    else :
        ans.append(chr(96 + k))
    i -= 1
print(''.join(map(str,ans)))

Submission status: Wrong Answer

Solution code:
def nod(n) :
    i = 1
    while n > 26 ** i :
        n = n - 26 ** i
        i += 1
    return i

n = int(input())
i = nod(n)
demo = [26 ** j for j in range(12)]
demo1 = []
k = 0
for j in demo :
    k += j
    demo1.append(k)
n = n - demo1[i - 1] + 1
i -= 1
ans = []
while i >= 0 :
    k = n // (26 ** i)
    if (26 ** i) * k >= n and n != 26:
        k -= 1
    n -= (26 ** i) * k
    if i > 0 :
        ans.append(chr(96 + k + 1))
    else :
        ans.append(chr(96 + k))
    i -= 1
print(''.join(map(str,ans)))

Submission status: Wrong Answer

Solution code:
def nod(n) :
    i = 1
    while n > 26 ** i :
        n = n - 26 ** i
        i += 1
    return i

n = int(input())
i = nod(n)
demo = [26 ** j for j in range(12)]
demo1 = []
k = 0
for j in demo :
    k += j
    demo1.append(k)
n = n - demo1[i - 1] + 1
print(n)
i -= 1
ans = []
while i >= 0 :
    k = n // (26 ** i)
    if (26 ** i) * k >= n and n != 26:
        k -= 1
    n -= (26 ** i) * k
    print(n,k)
    if i > 0 :
        ans.append(chr(96 + k + 1))
    else :
        ans.append(chr(96 + k))
    i -= 1
print(''.join(map(str,ans)))

Submission status: Wrong Answer

Solution code:
def main():

    n = int(input())
    ans = ''
    while n > 0:
        rem = n % 26
        if rem == 0:
            ans += 'z'
        else:
            ans += chr(rem + 96)

        # n -= 26 ** i
        n //= 26
        # if n == 0 or (n == 1 and rem == 0):
        #     break

    ans = ans[::-1] # 文字列の反転
    print(f'{ans}')

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
def main():

    n = int(input())
    ans = ''
    while True:
        rem = n % 26
        if rem == 0:
            ans += 'z'
        else:
            ans += chr(rem + 96)

        # n -= 26 ** i
        n //= 26
        if n == 0 or (n == 1 and rem == 0):
            break

    ans = ans[::-1] # 文字列の反転
    print(f'{ans}')

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
def main():

    n = int(input())
    i = 1
    ans = ''
    while True:
        rem = n % 26
        if rem == 0:
            ans += 'z'
        else:
            ans += chr(rem + 96)

        # n -= 26 ** i
        n //= 26
        if n <= 1:
            break
        i += 1
    ans = ans[::-1] # 文字列の反転
    print(f'{ans}')

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
# C - One Quadrillion and One Dalmatians
def main():
    N = int(input())
    res = ""
    while N:
        res += chr(96 + N % 26)
        N //= 26
    print(res[::-1])


if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
def nod(n) :
    i = 1
    while n > 26 ** i :
        n = n - 26 ** i
        i += 1
    return i

n = int(input())
i = nod(n)
demo = [26 ** j for j in range(12)]
demo1 = []
k = 0
for j in demo :
    k += j
    demo1.append(k)
n = n - demo1[i - 1] + 1
i -= 1
ans = []
while i >= 0 :
    k = n // (26 ** i)
    n -= (26 ** i) * k
    if i > 0 :
        ans.append(chr(96 + k + 1))
    else :
        ans.append(chr(96 + k))
    i -= 1
print(''.join(map(str,ans)))

Submission status: Wrong Answer

Solution code:
def main():

    n = int(input())
    i = 1
    ans = ''
    while True:
        rem = n % 26
        ans += chr(rem + 96)
        # n -= 26 ** i
        n //= 26
        if n == 0:
            break
        i += 1
    ans = ans[::-1] # 文字列の反転
    print(f'{ans}')

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

n = int(input())
res = []
while n > 0:
    cur = chr(n % 26 + ord('a') - 1)
    res.append(cur)
    n //= 26
print(''.join(res[::-1]))

Submission status: Wrong Answer

Solution code:
num=[26**i for i in range(11)]
num=num[::-1]
n=int(input())
#x=1000000000000001
ans=""
for i in range(len(num)):
    if n>=num[i]:
        x=n//num[i]
        n=n%num[i]
        ans+=chr(ord('a')+x-1)

print(ans)

Submission status: Wrong Answer

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

    chars = 'zabcdefghijklmnopqrstuvwxy'

    st = ''
    while True:
        a = n % 26
        st += chars[a]
        n = n // 26
        if n == 0 or (a == 0 and n == 1):
            break

    res = ''.join(list(reversed(st)))
    print(res)


main()

Submission status: Wrong Answer

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

    chars = 'zabcdefghijklmnopqrstuvwxy'

    st = ''
    while True:
        a = n % 26
        st += chars[a]
        n = n // 26
        if n == 0:
            break

    res = ''.join(list(reversed(st)))
    print(res)


main()

Submission status: Wrong Answer

Solution code:
import sys


def log(s):
    # print("| " + str(s), file=sys.stderr)
    pass


def output(x):
    print(x, flush=True)


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


def f(n, b):
    if n == 0:
        return [0]
    digits = []
    while n:
        digits.append(n % b)
        n //= b
    return digits[::-1]

def main():
    n = int(input())
    print("".join([chr(x+96) for x in f(n, 26)]))


main()

Submission status: Wrong Answer

Solution code:
 
# from math import factorial as fac
from collections import defaultdict
# from copy import deepcopy
import sys, math
f = None
try:
	f = open('q1.input', 'r')
except IOError:
	f = sys.stdin
if 'xrange' in dir(__builtins__):
	range = xrange
# print(f.readline())
sys.setrecursionlimit(10**2)

	
def print_case_iterable(case_num, iterable):
	print("Case #{}: {}".format(case_num," ".join(map(str,iterable))))

def print_case_number(case_num, iterable):
	print("Case #{}: {}".format(case_num,iterable))

def print_iterable(A):
	print (' '.join(A))

def read_int():
	return int(f.readline().strip())
def read_int_array():
	return [int(x) for x in f.readline().strip().split(" ")]
def rns():
	a =  [x for x in f.readline().split(" ")]
	return int(a[0]), a[1].strip()
def read_string():
	return list(f.readline().strip())
def ri():
	return int(f.readline().strip())
def ria():
	return [int(x) for x in f.readline().strip().split(" ")]
def rns():
	a =  [x for x in f.readline().split(" ")]
	return int(a[0]), a[1].strip()
def rs():
	return list(f.readline().strip())
def bi(x):
	return bin(x)[2:]





from collections import deque
import math
# NUMBER = 10**9 + 7
NUMBER = 998244353
def factorial(n) : 
	M = NUMBER
	f = 1
  
	for i in range(1, n + 1):  
		f = (f * i) % M # Now f never can  
						# exceed 10^9+7  
	return f
def mult(a,b):
	return (a * b) % NUMBER

def minus(a , b):
	return (a - b) % NUMBER

def plus(a , b):
	return (a + b) % NUMBER

def egcd(a, b):
	if a == 0:
		return (b, 0, 1)
	else:
		g, y, x = egcd(b % a, a)
		return (g, x - (b // a) * y, y)

def modinv(a):
	m = NUMBER
	g, x, y = egcd(a, m)
	if g != 1:
		raise Exception('modular inverse does not exist')
	else:
		return x % m
def choose(n,k):
	if n < k:
		assert false
	return  mult(factorial(n), modinv(mult(factorial(k),factorial(n-k))))
from collections import deque, defaultdict 
import heapq


from types import GeneratorType
def bootstrap(f, stack=[]):
	def wrappedfunc(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		else:
			to = f(*args, **kwargs)
			while True:
				if type(to) is GeneratorType:
					stack.append(to)
					to = next(to)
				else:
					stack.pop()
					if not stack:
						break
					to = stack[-1].send(to)
			return to

	return wrappedfunc


def dfs(g, timeIn, timeOut,depths,parents): 
	# assign In-time to node u 
	cnt = 0
	# node, neig_i, parent, depth
	stack = [[1,0,0,0]]
	while stack:
		v,neig_i,parent,depth = stack[-1]
		parents[v] = parent
		depths[v] = depth
		# print (v)
		if neig_i == 0:
			timeIn[v] = cnt    
			cnt+=1
		while neig_i < len(g[v]):
			u = g[v][neig_i]
			if u == parent:
				neig_i+=1
				continue
			stack[-1][1] = neig_i + 1
			stack.append([u,0,v,depth+1])
			break
		if neig_i == len(g[v]):
			stack.pop()
			timeOut[v] = cnt
			cnt += 1
  
def isAncestor(u: int, v: int, timeIn: list, timeOut: list) -> str: 
	return timeIn[u] <= timeIn[v] and timeOut[v] <= timeOut[u] 

cnt = 0
@bootstrap
def dfs(v,adj,timeIn, timeOut,depths,parents,parent=0,depth=0):
	global cnt
	parents[v] = parent
	depths[v] = depth
	timeIn[v] = cnt
	cnt+=1
	for u in adj[v]:
		if u == parent:
			continue
		yield dfs(u,adj,timeIn,timeOut,depths,parents,v,depth+1)
	timeOut[v] = cnt
	cnt+=1
	yield 


def solution(n):
	res = []
	while n > 26:
		res.append(chr(ord('a')+(n-1)%26))
		n//=26
	res.append(chr(ord('a')+(n-1)%26))
	return ''.join(reversed(res))


	
def main():
	T = 1
	# T = ri()
	for i in range(T):
		# s = rs()
		n = ri()
		# n,k = ria()
		# a=ria()

		x = solution(n)
		if 'xrange' not in dir(__builtins__):
			print(x)
		else:
			print >>output,str(x)# "Case #"+str(i+1)+':',
	if 'xrange' in dir(__builtins__):
		print(output.getvalue())
		output.close()

if 'xrange' in dir(__builtins__):
	import cStringIO
	output = cStringIO.StringIO()
#example usage:
#    for l in res:
#       print >>output, str(len(l)) + ' ' +  ' '.join(l)

if __name__ == '__main__':
	main()

Submission status: Wrong Answer

Solution code:
n = int(input())
x = 0
l = 0
while x < n:
    l += 1
    x += 26**l
for i in range(1,l):
    n -= 26**i
n -= 1
ans = ""
while n > 0:
    ans += chr(ord("a")+n%26)
    n //= 26
print(ans[::-1])

Submission status: Wrong Answer

Solution code:
def main():
    n = int(input())
    n -= 1
    res = ''
    while n > 0:
        n, m = divmod(n, 26)
        res += chr(97 + m)
        n -= 1

    print(res[::-1])


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
def main():
    n = int(input())
    n -= 1
    res = ''
    while n:
        n, m = divmod(n, 26)
        res += chr(97 + m)
        n -= 1

    print(res[::-1])


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
n=int(input())
s='aabcdefghijklmnopqrstuvwxyz'

l=[]
while n>=1:
  if n<27:
    l.append(n)
    break
  l.append(n%26)
  
  n=n//26

ss=str()
for i in range(len(l)-1,-1,-1):
  if l[i]==0:
    ss='z'*(len(l)-1)
    break
  ss+=s[l[i]]
print(str(ss))
#print(l)

Submission status: Wrong Answer

Solution code:
########関数部分##############
def Base_10_to_n(X, n):
    X -= 1
    if (int(X/n)):
            return Base_10_to_n((X)//n, n) + str(X%n) + " "
    return str(X%n) + " "
############################

def nanketa(X):
    n = 1
    a = 0
    while X > (26 ** n) + a:
        a += 26 ** n
        n += 1
    return n


#####関数をつかってみる．#####
######今回は二進数に変換######
x10 = int(input())
x2 = Base_10_to_n(x10, 26)
##print(x2)
ans = ""
a = ""
cnt = 0
x2 = list(x2.split(" "))[:-1]
x2 = list(map(int, x2))
#if x2[-1] == 25:
    #x2[-1] = -1
#x2[-1] += 1
print(x2)
for x in x2:
    ans += chr(x + 97)

print(ans)

Submission status: Wrong Answer

Solution code:
########関数部分##############
def Base_10_to_n(X, n):
    X -= 1
    if (int(X/n)):
            return Base_10_to_n((X)//n, n) + str(X%n) + " "
    return str(X%n) + " "
############################

def nanketa(X):
    n = 1
    a = 0
    while X > (26 ** n) + a:
        a += 26 ** n
        n += 1
    return n


#####関数をつかってみる．#####
######今回は二進数に変換######
x10 = int(input()) - 1
x2 = Base_10_to_n(x10, 26)
ans = ""
a = ""
cnt = 0
x2 = list(x2.split(" "))[:-1]
x2 = list(map(int, x2))
if x2[-1] == 25:
    x2[-1] = -1
x2[-1] += 1

for x in x2:
    ans += chr(x + 97)

print(ans)

Submission status: Wrong Answer

Solution code:
N = int(input())
alphabet = [chr(i) for i in range(97, 97+26)]

n = 1
s = 26
for i in range(1,12):
    if N <= s:
        n = i
        break
    else:
        s += 26**(i+1)
        
s = 0
for i in range(1,n):
    s += 26**i
    
N = N - s - 1
if N == 0:
    Ans = ""
    for _ in range(n):
        Ans += "a"
else:
    L = []
    while N > 0:
        L.append(N%26)
        N = N//26
    
    Ans = ""
    for x in reversed(L):
        Ans += alphabet[x]
print(Ans)

Submission status: Wrong Answer

Solution code:
########関数部分##############
def Base_10_to_n(X, n):
    if (int(X/n)):
            return Base_10_to_n(int((X - 1)/n), n)+str(X%n) + " "
    return str(X%n) + " "
############################

def nanketa(X):
    n = 1
    a = 0
    while X > (26 ** n) + a:
        a += 26 ** n
        n += 1
    return n


#####関数をつかってみる．#####
######今回は二進数に変換######
x10 = int(input()) - 1
x2 = Base_10_to_n(x10, 26)
ans = ""
a = ""
cnt = 0
x2 = list(x2.split(" "))[:-1]
x2 = list(map(int, x2))
for x in x2:
    ans += chr(x + 97)

print(ans)

Submission status: Wrong Answer

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

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

import sys
input = sys.stdin.readline

import math
#from math import gcd
import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache


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

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

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

######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(input()) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]

######OUTPUT######
def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()

#####Shorten#####
def DD(arg): return defaultdict(arg)


#####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

#####MakeDivisors######
def make_divisors(n):
  divisors = []
  for i in range(1, int(n**0.5)+1):
    if n % i == 0:
      divisors.append(i)
      if i != n // i: 
        divisors.append(n//i)
  return divisors

#####MakePrimes######
def make_primes(N):
  max = int(math.sqrt(N))
  seachList = [i for i in range(2,N+1)]
  primeNum = []
  while seachList[0] <= max:
    primeNum.append(seachList[0])
    tmp = seachList[0]
    seachList = [i for i in seachList if i % tmp != 0]
  primeNum.extend(seachList)
  return primeNum

#####GCD#####
def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

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

#####BitCount#####
def count_bit(n):
  count = 0
  while n:
    n &= n -1
    count += 1
  return count

#####ChangeBase#####
def base_10_to_n(X, n):
  if X//n:
    return base_10_to_n(X//n, n)+[X%n]
  return [X%n]

def base_n_to_10(X, n):
  return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))

def base_10_to_n_without_0(X, n):
  if (X-1)//n:
    return base_10_to_n_without_0(X//n, n)+[(X-1)%n]
  return [(X-1)%n]

#####IntLog#####
def int_log(n, a):
  count = 0
  while n>=a:
    n //= a
    count += 1
  return count

#############
# Main Code #
#############
N = I()
print(*[AZ[x] for x in base_10_to_n_without_0(N, 26)],sep="")

Submission status: Wrong Answer

Solution code:
N = int(input())
alphabet = [chr(i) for i in range(97, 97+26)]

n = 1
s = 26
for i in range(1,12):
    if N <= s:
        n = i
        break
    else:
        s += 26**(i+1)
        
s = 0
for i in range(1,n):
    s += 26**i
    
N = N - s - 1
L = []
while N > 0:
    L.append(N%26)
    N = N//26

Ans = ""
for x in reversed(L):
    Ans += alphabet[x]
print(Ans)

Submission status: Wrong Answer

Solution code:
n=int(input())
chars='xabcdefghijklmnopqrstuvwxyz'
ans=''
for i in range(11,-1,-1):
  if 26**i<=n:
    ans+=chars[n//(26**i)]
    n%=26**i
print(ans)

Submission status: Wrong Answer

Solution code:
n = int(input())
res=""
while (n>0):
    res+=(chr(96+n%26))
    n=n//26
print(res[::-1])

Submission status: Wrong Answer

Solution code:
N = int(input())
N -= 1

d = 26
for i in range(1,15):
    if N >= d:
        N -= d
        d *= 26
    else:
        d //= 26
        ans = ""
        # for j in range(i):
        #     ans += chr(N // d + ord("a"))
        #     N %= d
        #     d //= 26

        for j in range(i):
            ans += chr(N % 26 + ord("a"))
            N //= 26
        break

print(ans)

Submission status: Wrong Answer

Solution code:
n = int(input())
d = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
a = ''
while n:
  n -= 1
  a = d[n % 26] + a
  n //= 26
  print(a)

Submission status: Wrong Answer

Solution code:

#=input()
n=int(input())
#=map(int,input().split())
#=list(map(int,input().split()))
#=[list(map(int,input().split())) for _ in range()]

def f(x):
    return chr(x+96)

ans = ""
while n >= 26:
    ans += f(n % 26)
    n //= 26
ans += f(n)
print(ans[::-1])

Submission status: Wrong Answer

Solution code:
n = int(input())
d = ['z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
a = ''
f = 0
if n % 26 == 0:
  f = 1
  while n > f:
    a = d[n % 26] + a
    n //= 26
    print(a)

Submission status: Wrong Answer

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

patterns = [
    1,
    27,
    703,
    18279,
    475255,
    12356631,
    321272407,
    8353082583,
    217180147159,
    5646683826135,
    146813779479511,
    3817158266467287,
]


def solve(N: int):
    digit = 0
    for i, v26 in enumerate(patterns):
        if N < v26:
            digit = i
            break
    if i == 1:
        print(str(to_alphabet(N)).lower())
    else:
        pre = set(str(to_alphabet(N // 26)))
        is_end = len(pre) == 1 and pre == {"A"}
        if is_end and not N in patterns:
            print("z" * i)
        else:
            print(str(to_alphabet(N // 26) + to_alphabet(N % 26)).lower())
    return


def to_alphabet(num):
    if num == 0:
        return ""
    if num <= 26:
        return chr(64 + num)
    elif num % 26 == 0:
        return to_alphabet(num // 26 - 1) + chr(90)
    else:
        return to_alphabet(num // 26) + chr(64 + num % 26)


# Generated by 1.1.7.1 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()
    N = int(next(tokens))  # type: int
    solve(N)


if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
from collections import deque

def to_char(n):
    base = ord('a')
    return chr(base + n)

def main():
    N = int(input())
    q = deque([])
    while N > 0:
        v = N % 26
        q.appendleft(v)
        N //= 26
    # print(q)
    borrow = False
    len_q = len(q)
    for i in range(len_q):
        index = len_q - 1 - i
        if borrow:
            q[index] -= 1
            borrow = False
        if q[index] == 0:
            borrow = 1
            q[index] = 25
        else:
            q[index] -= 1
    if borrow:
        q.popleft()

    print(''.join(map(to_char, q)))

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import math

def convertToChar(num):
   if(num==0):
       return chr(96+26)
   else:return chr(96+num)
  
n = int(input())

if(n>26):
    length = math.ceil(math.log(n-26,26))
else:
    length = 1
s=""
for i in range(length):
    s+=convertToChar((n//26**i)%26)
    
print(s[::-1])