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

Solution (Python):
def main():
    n = int(input())
    ans = []
    for i in range(1, 12):
        if n <= 26**i:
            n -= 1
            for j in range(i):
                a = n % 26
                ans.append(chr(97+a))
                n = n // 26
            break
        else:
            n -= 26**i
    print(*ans[::-1], sep='')
 
if __name__ == '__main__':
    main()

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

ans=[]
a=ord("a")
while N>0:
    N-=1
    chrr=N%26
    ans.append(chr(a+chrr))
    N//=26


print("".join(ans[::-1]))

Solution (Python):
import sys
from string import ascii_lowercase

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    N = int(readline())

    ans = []
    while N:
        N, r = (N - 1) // 26, (N - 1) % 26
        ans.append(ascii_lowercase[r])

    print(''.join(reversed(ans)))
    return


if __name__ == '__main__':
    main()

Solution (Python):


def solve(n,s=""):
    if n == 0:
        return s
    else:
        return solve((n-1-26)//26+1,str(chr(ord("a")+(n-1)%26))+s)



def main():
    N = int(input())
    print(solve(N))


if __name__ == '__main__':
    main()

Solution (Python):

import collections
import sys
import copy
import re


def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())


def main():
    N = I()
    ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
    name_roop = []

    level = 1

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

    
    
    
    


if __name__ == '__main__':
    main()

Solution (Python):
ans=[]
N=int(input())
N-=1
count=0
for l in range(1,15):
    if N>=26**l:
        N-=26**l
        continue
    count=l
    break
for i in range(count):
    d=N%26
    ans.append(chr(d+ord("a")))
    N//=26
ans.reverse()
print(*ans,sep="")

Solution (Python):
import sys
import itertools

import time
import math
 
sys.setrecursionlimit(10 ** 7)
 
from collections import defaultdict
 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines




N = int(input())

x = 26
d = 1
while N > x:
    N -= x
    x *= 26
    d += 1
N -= 1
ans = ''
for i in range(d):
    ans += chr(ord('a') + N % 26)
    N //= 26

print(ans[::-1])

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

ans = ''
while N > 0:
    N -= 1
    ans += chr(ord('a') + N % 26)
    N //= 26
print(ans[::-1])

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2
from itertools import accumulate, permutations, combinations, combinations_with_replacement, 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, insort, insort_left
from fractions import gcd
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


N = INT()
ans = []

while N != 0:
	N -= 1
	p, r = divmod(N, 26)
	ans.append(ascii_lowercase[r])
	N = p

print("".join(ans[::-1]))

Solution (Python):
N=int(input())
alpha=list("abcdefghijklmnopqrstuvwxyz")
ans=""
while True:
  N-=1
  a=N%26
  N=N//26
  ans=alpha[a]+ans
  
  if N==0:
    break
print(ans)

Solution (Python):
import sys
from string import ascii_lowercase

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    N = int(readline())

    ans = []
    while N:
        N, r = N // 26, N % 26
        if r == 0:
            r = 26
            N -= 1
        ans.append(ascii_lowercase[r - 1])

    print(''.join(reversed(ans)))
    return


if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
data = ''

while n > 0:
    n -= 1
    r = n % 26
    data += chr(r + ord('a'))
    n //= 26

print(data[::-1])

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

def main():
    n = int(input())
    compare = [1]
    total = 1
    for i in range(1, 11):
        now = 26**i
        total = total+now
        if n < total:
            break
        compare.append(now)
    ans = ''
    n -= sum(compare)
    for i_compare in compare[::-1]:
        q, mod = divmod(n, i_compare)
        ans += chr(97+q)
        n = mod

    print(ans)
    return


if __name__ == "__main__":
    main()
    sys.exit(0)

Solution (Python):
import string


N = int(input())
n_digits = len(str(1000000000000001))
letters = string.ascii_lowercase


x = N
ans = []











while True:
    x -= 1
    mod = x % 26
    
    x = x // 26
    
    ans.append(mod)
    
    if x == 0:
        break
    

ans = ans[::-1]
print("".join([ letters[v] for v in ans ]))

Solution (Python):
n=int(input())
keta=[26]
t=2
while keta[-1]<10**15+1:
    keta.append(keta[-1]+26**t)
    t+=1


import bisect,sys
nagasa=bisect.bisect_left(keta,n)+1


alpha='abcdefghijklmnopqrstuvwxyza'
if nagasa==1:
    print(alpha[n-1])
    sys.exit()

n-=keta[nagasa-2]
n-=1

ans=''
L=[]
while n>0:
    L.append(n%26)
    n//=26
while len(L)<nagasa:
    L.append(0)
for i in L:
    ans+=alpha[i]
print(ans[::-1])

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

alphabets = [chr(i) for i in range(97, 97+26)] 

E = []
while N>=1:
  N -= 1
  E.append( int(N%26) )
  N = N/26

print("".join(reversed([alphabets[i] for i in E ] ))  )

Solution (Python):
import string


N = int(input())
n_digits = len(str(1000000000000001))
letters = string.ascii_lowercase

x = N - 1
ans = []











while True:
    
    mod = x % 26
    div = x // 26
    
    
    ans.append(mod)
    if div == 0:
        break
    x = div - 1

ans = ans[::-1]
print("".join([ letters[v] for v in ans ]))

Solution (Python):
N = int(input())
alphabets = []
for i in range(26):
    alphabets.append(chr(ord("a")+i))
ans = ""
i = 0
while N > 0:
    N -= 1
    ans += alphabets[N%26]
    N //= 26
print(ans[::-1])

Solution (Python):
N = int(input())
ans = ''
while N > 0:
  N -= 1
  ans += chr(ord('a') + N % 26)
  N //= 26
print(ans[::-1])

Solution (Python):
import sys

sys.setrecursionlimit(300000)


def I(): return int(sys.stdin.readline())


def MI(): return map(int, sys.stdin.readline().split())


def MI0(): return map(lambda s: int(s) - 1, sys.stdin.readline().split())


def LMI(): return list(map(int, sys.stdin.readline().split()))


def LMI0(): return list(map(lambda s: int(s) - 1, sys.stdin.readline().split()))


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

from string import ascii_lowercase

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

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

def num_base10_to_num_baseN(num_base_10, base_N):
    if num_base_10 < base_N:
        return [num_base_10]
    else:
        result_list = num_base10_to_num_baseN(num_base_10 // base_N, base_N)
        result_list.append(num_base_10 % base_N)
        return result_list

s = num_base10_to_num_baseN(n, 26)

for i in range(len(s) - 1, 0, -1):
    if s[i] <= 0:
        s[i] += 26
        s[i - 1] -= 1

print("".join([chr(96 + x) for x in s if x != 0]))

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

N = int(input())
print(num2alpha(N).lower())

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

N = int(input())

bin_26 = []

while N > 0:
    tmp = N % 26
    if tmp == 0:
        tmp = 26
    bin_26.append(tmp)
    N -= tmp
    N //= 26

bin_26.reverse()



ans = []

for b in bin_26:
    c = ord("a") + (b - 1)
    ans.append(chr(c))

print("".join(ans))

Solution (Python):
num = int(input())
s = 'abcdefghijklmnopqrstuvwxyz'
ans = ''

while num > 0:
    num, rest = divmod(num, 26)
    ans += s[rest - 1]
    if rest == 0:
        num -= 1

print(ans[::-1])

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

Solution (Python):
N = int(input())
ans = ''
while N > 0:
    N -= 1
    ans += chr(ord('a') + N % 26)
    N //= 26
print(ans[::-1])

Solution (Python):



import sys


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

def Base_10_to_n(i10, n, ans_list:list):
    
    i10 -= 1
    if(int(i10/n)):
        ans_list.append(Base_10_to_n(int(i10/n), n, ans_list))
        return str(i10%n)
    return str(i10%n)


def resolve():
    n = int(input().rstrip())
    n_list = []
    ans_list = []

    n_list.append(Base_10_to_n(n, 26, n_list))

    for n26 in n_list:
        string = ord("a") + int(n26)
        ans_list.append(chr(string))

    ans_string = ""
    for st in ans_list:
        ans_string += st
    print(ans_string.rstrip())

if __name__ == "__main__":
    resolve()

Solution (Python):
n = int(input())
a = 26
ans = ''
while n != 0:
  n -= 1
  ans += chr(ord('a') + n % 26)
  n //= 26
print(ans[::-1])

Solution (Python):
N = int(input())
s = list("abcdefghijklmnopqrstuvwxyz")
ans=[]

while 1<=N:
    N -= 1    
    ans.insert(0, s[N%26])
    N //= 26

ans="".join(ans)
print(ans)

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


digit = 1  
num = pow(26, digit) 
while num < N:
    digit += 1
    num += pow(26, digit)



order = N - (num - pow(26, digit)) - 1



X = [0] * digit
cur = digit - 1
while order > 0:
    X[cur] = order % 26
    order //= 26
    cur -= 1


ans = []
for x in X:
    c = chr(ord('a') + x)
    ans.append(c)

print(''.join(ans))

Solution (Python):
import string

cs = string.ascii_lowercase
def factor(n):
    b = 26
    ds = [n % b]
    n //= b
    while n:
        d = n % b
        ds.append(d)
        n //= b
    return ds

n = int(input())
lst = [sum(26**i for i in range(p+1)) - 1 for p in range(1, 12)]
lst = [0] + lst
for i in range(1, len(lst)):
    if n <= lst[i]:
        pos = n - lst[i - 1] - 1
        fp = factor(pos)
        while len(fp) < i:
            fp.append(0)
        fp.reverse()

        print(''.join(cs[d] for d in fp))
        break

Solution (Python):
import math
N=int(input())
def num2alpha(num):
    if num<=26:
        return str.lower(chr(64+num))
    elif num%26==0:
        return str.lower(num2alpha(num//26-1)+chr(90))
    else:
        return str.lower(num2alpha(num//26)+chr(64+num%26))


print(num2alpha(N))

Solution (Python):

import math
n = int(input())
ans = ''
alp = 'abcdefghijklmnopqrstuvwxyz'
cnt = 0
res = [0] * 11
for i in range(1, 11):
    res[i] = res[i-1] + 26**i
keta = 1

for i in range(11):
    if n > res[i]:
        keta = i

n -= res[keta]


import numpy as np
aaa = np.base_repr(n-1,26)

aaa = str(aaa)
di = {'0':'a', '1':'b','2':'c','3':'d','4':'e','5':'f','6':'g','7':'h','8':'i','9':'j','A':'k','B':'l','C':'m','D':'n','E':'o','F':'p','G':'q','H':'r','I':'s','J':'t','K':'u','L':'v','M':'w','N':'x','O':'y','P':'z'}
for i in range(len(str(aaa))):
    ans = ans + di[aaa[i]]
if keta+1 - len(ans) > 0:
    ans = 'a' * (keta+1 - len(ans) ) + ans
print(ans)
"""
cnt = 10
while True:
    k = n//(26**cnt)
    if k > 0:
        k = n//(26**cnt)
        n -= k
        ans = ans + alp[k-1]
        print(cnt)
    cnt -= 1
    if n <= 26:
        print(n)
        ans = ans + alp[n-1]
        break
    if cnt == 0:
        break
print(ans)
"""

Solution (Python):
def base_k(n, k=26):
    ret = []
    ny = n
    while ny:

        ret.append(ny % k)
        ny //= k
    return ret[::-1]


def letter(i):
    return chr(i+97)


def solve(n):
    check = 26
    cnt = 1
    k = n
    while True:
        if n <= check:
            break
        check *= 26
        check += 26
        cnt += 1
    k -= check//26 - 1
    t = base_k(k-1)
    ans = ""
    if not t:
        ans = "a" * cnt
    else:
        for _ in range(cnt):
            if not t:
                ans += "a"
                continue
            ans += letter(t.pop())

    return ans[::-1]


n = int(input())
print(solve(n))

Solution (Python):
n = int(input())
alpha = "abcdefghijklmnopqrstuvwxyz"
answer = ""
while n > 0:
    n -= 1
    answer += alpha[n%26]
    n//=26
print(answer[::-1])

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


digit = 1  
num = pow(26, digit) 
while num < N:
    digit += 1
    num += pow(26, digit)



order = N - (num - pow(26, digit)) - 1



X = [0] * digit
cur = digit - 1
while order > 0:
    X[cur] = order % 26
    order //= 26
    cur -= 1


ans = []
a = ord('a')
for x in X:
    c = chr(a + x)
    ans.append(c)

print(''.join(ans))

Solution (Python):
import sys, collections, bisect, itertools, heapq, math, copy, string
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    N = I()

    ans = ''
    radix = 26
    while N > 0:
        ans += string.ascii_lowercase[N%radix-1]
        N = (N - 1) // radix

    print(ans[::-1])

if __name__ == '__main__':
    resolve()

Solution (Python):
n=int(input())
import sys
num2alpha = lambda c: chr(c+65).lower()

ans=[]

while True:
  n-=1
  ans.append(num2alpha(n%26))
  n=n//26
  if n<26:
    if n==0:
      break
    n-=1
    ans.append(num2alpha(n%26))
    break

for i in range(len(ans)):
  print(ans[-1-i], end='')


print()

Solution (Python):
N = int(input())
ans = ''

BASE=26
for i in range(12,-1,-1):
    tmp = pow(BASE,i)
    if tmp > N:
        continue
    
    N-=1
    ans += chr(ord('a') + N % 26)
    N //= 26
print(ans[::-1])

Solution (Python):
N = int(input())
res = []
while N:
    N -= 1
    N, r = divmod(N, 26)
    res.append(chr(r + ord('a')))
res.reverse()
print(''.join(res))

Solution (Python):
n = int(input())
ans = ''
while n>0:
  n -= 1
  ans += chr(ord('a') + n%26)
  n //= 26
print(ans[::-1])

Solution (Python):
n=int(input())
alpha=['z']+[chr(ord('a') + i) for i in range(26)]
list_num=[]
while n>=1:
  num=n%26
  list_num.append(num)
  if num==0:
    n-=1
  n=n//26
list_num.reverse()
list_alpha=[]
for i in list_num:
  s=alpha[i]
  list_alpha.append(s)
  
print(''.join(list_alpha))

Solution (Python):
n = int(input())
ans = ''
while n > 0:
    n -= 1
    ans = chr(n % 26 + 97) + ans
    n //= 26
print(ans)

Solution (Python):
n = int(input())
a = 0
Ans_list = []
alpha = ["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"]
qq = n % 26
if qq == 0:
    qq = 26
Ans_list.insert(0,qq)
b = n - qq
for i in range(10000):
    po = b // 26
    po2 = po % 26
    if po2 == 0:
        po2 = 26
    Ans_list.insert(0,po2)
    b = po - po2
    if b <= 0:
        break
Ans = ""
if n <= 26:
    del Ans_list[0]
for i in range(len(Ans_list)):
    Ans = Ans +  alpha[Ans_list[i]-1]
print(Ans)

Solution (Python):
n = int(input())
ans = ""
while n > 0:
    n -= 1
    ans += chr(ord('a') + n%26)
    
    n = n // 26
print(ans[::-1])

Solution (Python):
def f(n):
    if n == 0: return ""
    n -= 1
    return (f(n // 26) + chr(ord("a") + n % 26))

def main():
    from builtins import int, map, list, print
    import sys
    sys.setrecursionlimit(10 ** 6)

    input = (lambda: (sys.stdin.readline()).rstrip())
    input_list = (lambda: input().split())
    input_number = (lambda: int(input()))
    input_number_list = (lambda: list(map(int, input_list())))

    n = input_number()
    ans = f(n)
    print(ans)

if __name__ == '__main__':
    main()

Solution (Python):
n=int(input())
s=""
while n>0:n-=1;s+=chr(97+n%26);n//=26
print(s[::-1])

Solution (Python):
n = int(input())
s = 'abcdefghijklmnopqrstuvwxyz'
ans = ''
while n > 0:
  n, i = divmod(n - 1, 26)
  ans = s[i] + ans
print(ans)

Solution (Python):
g = []
def gcd(b):
    b-=1
    g.insert(0, b%26)
    if(b//26 > 0):
        gcd(b//26)
a = 'abcdefghijklmnopqrstuvwxyz'
n = int(input())
s = 0; i=0;
gcd(n)
ans = ''
for i in g:
    ans += a[i]
print(ans)

Solution (Python):
n=int(input())
s=""
while n>0:n-=1;s+=chr(97+n%26);n//=26
print(s[::-1])

Solution (Python):
n = int(input())-1
result = ""

while(1):
    tmp = n % 26
    result += chr(tmp+97)
    n = n // 26
    if n==0: break
    n -= 1
    
print(result[::-1])

Solution (Python):


n = int(input())
alphabet = ['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']


def base10to(n, b):

    n -= 1
    if (int(n//b)):
        return base10to(int(n//b), b) + alphabet[n % b]
    return alphabet[n % b]


print(base10to(n, 26))

Solution (Python):



import sys


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

def Base_10_to_n(i10, n, ans_list:list):
    i10 -= 1
    if(int(i10/n)):
        ans_list.append(Base_10_to_n(int(i10/n), n, ans_list))
        return str(i10%n)
    return str(i10%n)


def resolve():
    n = int(input().rstrip())
    n_list = []

    ans_list = []

    n_list.append(Base_10_to_n(n, 26, n_list))
    n26_list =[]
    for n26 in n_list:
        n26_list.append(int(n26))

    for n26 in n26_list:
        string = ord("a") + n26
        ans_list.append(chr(string))

    ans_string = ""
    for st in ans_list:
        ans_string += st
    print(ans_string.rstrip())

if __name__ == "__main__":
    resolve()

Solution (Python):
import string


N = int(input())
n_digits = len(str(1000000000000001))
letters = string.ascii_lowercase

x = N - 1
ans = []












while True:
    mod = x % 26
    div = x // 26
    
    ans.append(mod)
    if div == 0:
        break
    x = div - 1

ans = ans[::-1]

print("".join([ letters[v] for v in ans ]))

Solution (Python):
n = int(input())
alpha = "abcdefghijklmnopqrstuvwxyz"
answer = ""
while n > 0:
  n -= 1
  answer += alpha[n%26]
  n //= 26
print(answer[::-1])

Solution (Python):
import string
from collections import deque

letters=string.ascii_lowercase

N = int(input())

ans = deque()
while True:
    N -= 1
    x = N//26
    y = N%26
    ans.appendleft(letters[y])
    N = x
    if N == 0:
        break

print(*ans, sep="")

Solution (Python):
n = int(input())
for i in range(1,12):
    if n <= pow(26,i):
        d = i
        break
    n = n - pow(26,i)
d = d - 1 
n = n - 1
ans =''
for i in range(d):
    tmp = divmod(n,pow(26,d-i))
    ans = ans+ chr(97+tmp[0])
    n = tmp[1]
print(ans + chr(97+n))

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

cnt=1
tmp=26

while n>tmp:
    cnt+=1
    tmp+=26**cnt
 
num=n-(tmp//26)
 
alp=["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"]
 
ans=["0"]*cnt
for i in range(cnt):
    j=num%26
    num//=26
    ans[-i-1]=alp[j]

print(*ans, sep='')

Solution (Python):
n = int(input())
eigo = 'abcdefghijklmnopqrstuvwxyz'

keta = 1
while n > 26**keta:
    n -= 26**keta
    keta += 1

ans =''
n = n-1
for i in range(keta):
    a =n // 26**(keta-1-i)
    ans += eigo[a]
    n = n % (26**(keta-1-i))
print(ans)

Solution (Python):
n = int(input())
s = 'abcdefghijklmnopqrstuvwxyz'
t = 0
res = ""
while n > 26:
    n -= 1
    res += s[n % 26]
    n //= 26

res += s[n - 1]
print(res[::-1])

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

cnt=1
tmp=26

while n>tmp:
    cnt+=1
    tmp+=26**cnt
 
num=n-(tmp//26)
 
alp=["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"]
 
if n<=26:
    ans=alp[n-1]
    print(ans)
else:
    ans=["0"]*cnt
    for i in range(cnt):
        j=num%26
        ans[-i-1]=alp[j]
        num//=26
    
    print(*ans, sep='')

Solution (Python):
n = int(input())-1
result = ""
v = 11

tmp = n % 26
result += chr(tmp+97)
n = n // 26

if n!=0:
    while(1):
        n -= 1
        
        tmp = n % 26
        result += chr(tmp+97)
        n = n // 26
        if n==0: break

print(result[::-1])

Solution (Python):
import sys

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

in_n = lambda: int(readline())
in_nn = lambda: map(int, readline().split())
in_na = lambda: map(int, read().split())
in_s = lambda: readline().rstrip().decode('utf-8')


def main():

    N = in_n()
    ans = []

    l = 1
    t = 0
    while True:
        if N <= t + 26 ** l:
            break
        t += 26 ** l
        l += 1

    ans = []

    N = N - t - 1
    for i in range(l):
        ans.append(chr(ord('a') + N % 26))
        N -= N % 26
        N = N // 26

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


if __name__ == '__main__':
    main()

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

lis=[26, 702, 18278, 475254, 12356630, 321272406, 8353082582, 217180147158, 5646683826134, 146813779479510, 1000000000000001]


k=0
for i in range(len(lis)):
  if lis[i]>=n:
    k=i
    break

s=""
if k==0:
  s+=chr(n+96)
else:
  for i in range(k+1):
    n-=1
    x=int(n%26)
    s+=(chr(x+ord('a')))
    n=int(n//26)

print(s[::-1])

Solution (Python):
import sys
import math
import heapq
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, m=DVSR): return pow(x, m - 2, m)
def DIV(x, y, m=DVSR): return (x * INV(y, m)) % m
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def FLIST(n):
    res = [1]
    for i in range(1, n+1): res.append(res[i-1]*i%DVSR)
    return res

N=II()-1
crr=[chr(97 + i) for i in range(26)]

res = []
cnt = 0
for i in range(1, 15):
    if N >= 26**i:
        cnt = i
        
        N -= 26**i


while N:
    res.append(crr[N%26])
    N //= 26
res.reverse()


print(("a"*(cnt+1) + "".join(res))[-(cnt+1):])

Solution (Python):
n = int(input())
num = 26
arr = []
ans = ""
moji = "abcdefghijklmnopqrstuvwxyz"
flg = False

ar = []
n = n - 1
for i in range(10000):
    arr.append(n % num)
    n = n // num - 1
    if n < 0:
        break

arr.reverse()

ans = ""

for i in arr:
    ans +=moji[i]
print(ans)

Solution (Python):
n = int(input())
s = 'abcdefghijklmnopqrstuvwxyz'


def calc(n, ans):
  n, i = divmod((n - 1), 26)
  ans = s[i] + ans
  if (n > 0):
    return calc(n, ans)
  else:
    return ans


ans = calc(n, '')
print(ans)

Solution (Python):
def solve():
    n = int(input())
    l = 0
    ans = ''
    for i in range(1, 12):
        if n <= 26 ** i:
            l = i
            break
        n = n - 26 ** i
    k = n - 1
    for i in range(l):
        ans = chr(k % 26 + 97) + ans
        k = k // 26

    print(ans)











if __name__ == '__main__':
    solve()

Solution (Python):
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate


def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))



def read_a_int(): return int(read())


def read_ints(): return list(map(int, read().split()))


def read_col(H):
    '''H is number of rows
    A列、B列が与えられるようなとき
    ex1)A,B=read_col(H)    ex2) A,=read_col(H) 
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return tuple(map(list, zip(*ret)))


def read_tuple(H):
    '''H is number of rows'''
    ret = []
    for _ in range(H):
        ret.append(tuple(map(int, read().split())))
    return ret


def read_matrix(H):
    '''H is number of rows'''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return ret
    


MOD = 10**9 + 7
INF = 2**31  

from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right  
from math import gcd



def ord_from_a(char):
    return ord(char) - ord('a')


def chr_from_a(n: int):
    
    if n == -1:
        n = 25
    return chr(n + ord('a'))


N = read_a_int()

num = 0
for i in range(1, 100):
    num += 26**i
    if N <= num:
        break  
n = i
N -= (26 ** n - 1) // 25

ans = ''
for i in range(n):
    N, r = divmod(N, 26)
    ans = chr_from_a(r) + ans


print(ans)

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

ans=''
while(n>0):
    n=n-1
    ans=ans+chr(ord('a')+n%26)
    n=n//26
print(ans[::-1])

Solution (Python):
n=int(input())
ex=0
for i in range(1,100):
    ex+=26**i
    if(n<=ex):
        digit=i
        break
x=n-ex+26**digit-1
sum=''
for i in range(digit):
    q,mod=divmod(x,26)
    sum+=chr(ord('a')+mod)
    if(q==0):
        for j in range (digit-i-1):
            sum+='a'
        break
    x=q
    
    
print(sum[::-1])

Solution (Python):
N=int(input())
cher=[0]*26
ans_list=[]

for i,j in enumerate('zabcdefghijklmnopqrstuvwxy'):
    cher[i]=j

while N>26:
    ans_list.append(cher[N%26])
    if N%26==0:N-=1
    N=N//26

ans_list.append(cher[N%26])
print(''.join(ans_list)[::-1])

Solution (Python):
import os
import sys
from io import BytesIO, IOBase
import math

def main():
    
    
    n=int(input())
    res=""
    while n:
        n-=1
        res=chr(ord("a")+n%26)+res
        n//=26
    
    
    print(res)


BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")



if __name__ == "__main__":
    main()

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


x = 26
y = n
ans = 'a'
while y > x:
    y -= x
    x *= 26
    ans += 'a'

y -= 1
ans = list(ans)
for i in range(len(ans)):
    x = pow(26, len(ans)-i-1)
    while y >= x:
        y -= x
        ans[i] = chr(ord(ans[i])+1)

print(''.join(ans))

Solution (Python):
n = int(input())
n -= 1

for i in range(1, 15):
    if n >= 26**i:
        n -= 26**i
        continue
    ans = ""
    for j in range(i):
        ans += chr(n%26 + ord("a"))
        n //= 26
    print(ans[::-1])
    break

Solution (Python):
n = int(input())
ans = ""

while (n > 0):
    n -= 1
    ans += chr(ord("a") + n % 26)
    n //= 26

print(ans[::-1])

Solution (Python):

import itertools


n = int(input())

list_26 = [26]
while list_26[-1] < 1000000000000001:
    list_26.append(list_26[-1]*26)

list_26 = list(itertools.accumulate(list_26))


for i in range(len(list_26)):
    if n <= list_26[i]:
        break
digit = i

if i != 0:
    n -= list_26[i-1]


n -= 1


def base_10_to_n(x, n):
    x_dummy = x
    out = []
    while x_dummy > 0:
        out.append(int(x_dummy % n))
        x_dummy = int(x_dummy/n)
    if out == []:
        return [0]
    return out


ans = base_10_to_n(n, 26)

ans += [0]*(i+1-len(ans))
ans.reverse()

for i in ans:
    print(chr(i+97), end="")
print()