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):
import sys                                                                                                                                                                                                  
                                                                                                                                                                                                            
l = sys.stdin.readline().rstrip('\n').split(' ')                                                                                                                                                            
N = int(l[0])                                                                                                                                                                                               
                                                                                                                                                                                                            
digits = 1                                                                                                                                                                                                  
                                                                                                                                                                                                            
while True:                                                                                                                                                                                                 
    ub = 26 ** digits                                                                                                                                                                                       
    if N <= ub:                                                                                                                                                                                             
        break                                                                                                                                                                                               
    N -= ub                                                                                                                                                                                                 
    digits += 1                                                                                                                                                                                             
                                                                                                                                                                                                            
ans = ''                                                                                                                                                                                                    
N -= 1                                                                                                                                                                                                      
                                                                                                                                                                                                            
for pos in range(digits):                                                                                                                                                                                   
    offset = N % 26                                                                                                                                                                                         
    digit = chr(ord('a') + offset)                                                                                                                                                                          
    ans = digit + ans                                                                                                                                                                                       
    N //= 26                                                                                                                                                                                                
                                                                                                                                                                                                            
print(ans)

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


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


if __name__ == '__main__':
    main()

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

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

print(this(S).lower())

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

nn = n // 26
amari = n % 26

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)
        
ans = num2alpha(n)

print(ans.lower())

Solution (Python):
import sys; input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
from collections import defaultdict
con = 10 ** 9 + 7; INF = float("inf")

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


def main():
	N = int(input())
	alpha = [chr(i) for i in range(97, 123)]
	cnt = 0
	var = None
	for i in range(1, 100):
		if N <= 26 ** i:
			var = i
			break
		N -= 26 ** i

	N -= 1
	
	
	ans = ""
	for i in range(var):
		ans += alpha[N % 26]
		N = int(N // 26)

	print(ans[::-1])





if __name__ == '__main__':
	main()

Solution (Python):

import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from collections import deque
from functools import lru_cache
import bisect
import re
import queue
import decimal


class Scanner():
    @staticmethod
    def int():
        return int(sys.stdin.readline().rstrip())

    @staticmethod
    def string():
        return sys.stdin.readline().rstrip()

    @staticmethod
    def map_int():
        return [int(x) for x in Scanner.string().split()]

    @staticmethod
    def string_list(n):
        return [Scanner.string() for i in range(n)]

    @staticmethod
    def int_list_list(n):
        return [Scanner.map_int() for i in range(n)]

    @staticmethod
    def int_cols_list(n):
        return [Scanner.int() for i in range(n)]


class Math():
    @staticmethod
    def gcd(a, b):
        if b == 0:
            return a
        return Math.gcd(b, a % b)

    @staticmethod
    def lcm(a, b):
        return (a * b) // Math.gcd(a, b)

    @staticmethod
    def divisor(n):
        res = []
        i = 1
        for i in range(1, int(n ** 0.5) + 1):
            if n % i == 0:
                res.append(i)
                if i != n // i:
                    res.append(n // i)
        return res

    @staticmethod
    def round_up(a, b):
        return -(-a // b)

    @staticmethod
    def is_prime(n):
        if n < 2:
            return False
        if n == 2:
            return True
        if n % 2 == 0:
            return False
        d = int(n ** 0.5) + 1
        for i in range(3, d + 1, 2):
            if n % i == 0:
                return False
        return True

    @staticmethod
    def fact(N):
        res = {}
        tmp = N
        for i in range(2, int(N ** 0.5 + 1) + 1):
            cnt = 0
            while tmp % i == 0:
                cnt += 1
                tmp //= i
            if cnt > 0:
                res[i] = cnt
        if tmp != 1:
            res[tmp] = 1
        if res == {}:
            res[N] = 1
        return res


def pop_count(x):
    x = x - ((x >> 1) & 0x5555555555555555)
    x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
    x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
    x = x + (x >> 8)
    x = x + (x >> 16)
    x = x + (x >> 32)
    return x & 0x0000007f


MOD = int(1e09) + 7
INF = int(1e15)


def to_26(X):
    X -= 1
    if int(X / 26):
        return to_26(int(X / 26)) + string.ascii_lowercase[X % 26]
    else:
        return string.ascii_lowercase[X % 26]


def solve():
    N = Scanner.int()
    print(to_26(N))


def main():
    
    
    
    
    
    solve()


if __name__ == "__main__":
    main()

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

def num2alpha(num):
    if num<=26:
        return chr(96+num)
    elif num%26==0:
        return num2alpha(num//26-1)+chr(122)
    else:
        return num2alpha(num//26)+chr(96+num%26)

print(num2alpha(N))

Solution (Python):
import string

N = int(input())


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


def get_dog_name(N):
    N -= 1
    for i in range(1, 14):
        num = 26 ** i
        if N >= num:
            N -= num
            continue
        base26 = number_to_base(N, 26)
        name = "".join([string.ascii_lowercase[i] for i in base26])
        return ("a" * i)[:-len(name)] + name


print(get_dog_name(N))

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)

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

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):
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)
def resolve():
    s = int(input())
    print(str.lower(num2alpha(s)))
resolve()

Solution (Python):

import sys
import numpy as np


def solve(N: int):
    n = N
    ans = ""
    
    while n>0:
        mod = (n-1) % 26
        ans = chr(97+mod) + ans
        n = (n-mod)//26

    print(ans)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    solve(N)

if __name__ == '__main__':
    main()

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

res = []
a = 26
while N > 0:
    x = N%a
    if x == 0:
        res.append(26)
        N -= a
        N //= a
    else:
        res.append(x)
        N //= a

res.reverse()
res = [chr(0x60+r) for r in res]
print("".join(res))

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

    def moji_list(a, b):
        
        
        
        
        
        
        return [chr(i) for i in range(a, b)]


    n = int(readline())
    al = ['z'] + moji_list(97, 123)
    ans = ''
    for i in range(1, 10 ** 6):
        n, check = divmod(n, 26)
        if check == 0:
            n -= 1
        ans += al[check]
        if n == 0:
            print(ans[::-1])
            break


if __name__ == '__main__':
    main()

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


def main(input, print):
    n = int(input())
    ans = ''
    n -= 1
    ans += chr(ord('a')+n % 26)
    now = n // 26
    while now > 0:
        now -= 1
        ans = chr(ord('a')+now % 26) + ans
        now = now//26
    print(ans)


if __name__ == '__main__':
    main(sys.stdin.readline, print)

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


def read():
    N = int(input().strip())
    return N,


def solve(N):
    C = "abcdefghijklmnopqrstuvwxyz"
    name = []
    while N > 0:
        c = C[(N-1) % 26]
        name.append(c)
        N = (N-1) // 26
    return "".join(name)[::-1]


if __name__ == '__main__':
    inputs = read()
    outputs = solve(*inputs)
    if outputs is not None:
        print("%s" % str(outputs))

Solution (Python):
import sys

import math
import collections

import bisect
import itertools
import fractions

import copy

import decimal

import queue



sys.setrecursionlimit(10000001)
INF = 10 ** 16
MOD = 10 ** 9 + 7


ni = lambda: int(sys.stdin.readline())
ns = lambda: map(int, sys.stdin.readline().split())
na = lambda: list(map(int, sys.stdin.readline().split()))



def main():
    n = ni()

    diver = 26
    ans = []
    while n > 0:
        n -= 1
        ans.append(chr(97 + n % diver))
        n //= diver

    ans.reverse()
    print(*ans, sep="")


if __name__ == '__main__':
    main()

Solution (Python):

import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub


import sys


buff_readline = sys.stdin.readline
readline = sys.stdin.readline

INF = 2**62-1


def read_int():
    return int(buff_readline())


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


def read_float():
    return float(buff_readline())


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


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


def read_str_n():
    return readline().strip().split()

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


def mt(f):
    import time

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

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

    return wrap


@mt
def slv(N):
    a = 26
    ans = []
    for i in range(100000):
        c = N % a
        if c == 0:
            c = 26
            N -= 1
        N //= a
        ans.append(chr(ord('a')+c-1))
        if N == 0:
            break
    return ''.join(reversed(ans))


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


if __name__ == '__main__':
    main()

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

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)

res = num2alpha(n)

print(res.lower())

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

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

print(al(n).lower())

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

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

name = name[::-1]
print(name)

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)
def main():
  a=int(input())
  print(num2alpha(a).lower())

main()

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

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

    ans = ''

    alphas = [chr(i + ord('a')) for i in range(26)]

    while N > 0:
        r = N % 26
        if r == 0:
            ans = alphas[-1] + ans
            N = N // 26 - 1
        else:
            ans = alphas[r - 1] + ans
            N = N // 26
    
    print(ans)


solve()

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

ans = ""
while N>0:
    n = N%26
    if n==0:
        ans += "z"
        N -= 1
    else:
        ans += chr(ord("a") + n-1)
    N //= 26
print(ans[::-1])

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

ans = ""
while N > 0:
  surplus = N % 26
  if surplus == 0:
    ans = 'z' + ans
    N //= 26
    N -= 1
  else:
    ans = chr(surplus + 96) + ans
    N //= 26
print(ans)

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

def num2alpha(num):
  if num <= 26:
  	return chr(96+num)
  elif num%26 == 0:
    return num2alpha(num//26-1) + chr(122)
  else:
    return num2alpha(num//26) + chr(96+num%26)

print(num2alpha(n))

Solution (Python):
def main():
    
    
    N=int(input())
    ans=""
    while N!=0:
        tmp=N%26
        N//=26
        if tmp==0:
            ans="z"+ans
            N-=1
        else:
            ans=chr(tmp-1+ord("a"))+ans
    print(ans)

main()

Solution (Python):
import sys
input=sys.stdin.readline
n=int(input())
ans=[]
while True:
    x=n%26
    if x==0:
        ans.append('z')
        n=(n-26)//26
    else:
        ans.append(chr(x+96))
        n=(n-x)//26
    if n==0:
        break
l=len(ans)
for i in range(l-1,-1,-1):
    print(ans[i],end='')

Solution (Python):
import sys


def _i(): return int(sys.stdin.readline().strip())


def main():
    n = _i()
    r = ""
    while True:
        n -= 1
        m = n % 26
        r = chr(97 + m) + r
        n -= m
        n //= 26
        if n == 0:
            break

    return r


if __name__ == "__main__":
    print(main())

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


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


print(str(convert(n)).lower())

Solution (Python):
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 8)
from itertools import accumulate
from itertools import permutations
from itertools import combinations
from collections import defaultdict
from collections import Counter
import fractions
import math
from collections import deque
from bisect import bisect_left
from bisect import bisect_right
from bisect import insort_left
import itertools
from heapq import heapify
from heapq import heappop
from heapq import heappush
import heapq
from copy import deepcopy
from decimal import Decimal
alf = list("abcdefghijklmnopqrstuvwxyz")
ALF = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")

INF = float("inf")


N = int(input())
ans = []
while N > 0:
    N -= 1
    x = N % 26
    N = N // 26
    ans.append(alf[x])
ans.reverse()
print("".join(ans))

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

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)

print(str.lower(num2alpha(n)))

Solution (Python):
n=int(input())
letter="zabcdefghijklmnopqrstuvwxy"
nam=[]
p=n
while p>0:
  q=p%26
  p=p//26
  if q==0:
    p-=1
  nam.append(letter[q])
nam.reverse()
ans="".join(nam)
print(ans)

Solution (Python):
n = int(input())
alph = [chr(i) for i in range(97, 123)]
x = 26
for i in range(1, 50):
    if n > x:
        n -= x
        x *= 26
    else:
        n -= 1
        ans = [0] * i
        for j in range(i):
            ans[j] = alph[n % 26]
            n //= 26
        ans.reverse()
        print("".join(ans))
        exit()

Solution (Python):
from sys import stdin,stdout
input = stdin.readline
output = stdout.write
n = int(input())
ans = ''
while n>0:
    if n%26:ans+=chr(64+n%26)
    else:
        ans+='Z'
        n-=1
    n//=26
ans=ans[::-1]
print(ans.lower()+'\n')

Solution (Python):
def num2alpha(num):
    if num<=26:
        return chr(96+num)
    elif num%26==0:
        return num2alpha(num//26-1)+chr(96+26)
    else:
        return num2alpha(num//26)+chr(96+num%26)
print(num2alpha(int(input())))

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

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)
      
      
print(num2alpha(N).lower())

Solution (Python):
from sys import stdin, setrecursionlimit
input = stdin.buffer.readline
setrecursionlimit(10 ** 7)

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

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

N = int(input())





def n2a(n):
    return chr(n - 1 + ord("a")) if n else "z"
    
answer = ""
while N:
    answer += n2a(N % 26)
    N -= 1
    N //= 26
print(answer[::-1])

Solution (Python):
n = int(input())
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)
print(num2alpha(n).lower())

Solution (Python):
from heapq import *
import sys
from collections import *
from itertools import *
from decimal import *
import copy
from bisect import *
import math
sys.setrecursionlimit(4100000)
def gcd(a,b):
    if(a%b==0):return(b)
    return (gcd(b,a%b))
input=lambda :sys.stdin.readline().rstrip()

N=int(input())-1

c=26
a=1
while N>=c:

    N-=c
    c*=26
    a+=1



lst=[0 for i in range(a)]
b=0
while N:
    a=N%26
    lst[b]=a
    N//=26
    b+=1

lst.reverse()
S="".join([chr(i+ord("a")) for i in lst])
print(S)

Solution (Python):
from decimal import *

n=Decimal(input())
chars=['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']
ans=''
while n>0:
    r=n%26
    ans = chars[int(r)]+ans
    if r==0:
        n = n//26-1
    else:
        n=n//26

print(ans)

Solution (Python):
N = int(input())
ans = []
tmp_n = N
while True:
    s, r = divmod(tmp_n, 26)
    if r == 0:
        r = 26
        s -= 1
    ans.append(chr(r+96))
    tmp_n = s
    if s <= 0:
        break
print("".join(ans[::-1]))

Solution (Python):
n = int(input())
ans = ""
n -= 1
while True:
    ans = chr(97 + n % 26) + ans
    n = n // 26
    if n == 0:
        break
    n -= 1
print(ans)

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]

def main():
    n=II()-1
    ans=""
    while 1:
        if n<=25:
            ans += chr(97 + n)
            break
        r=n%26
        ans+=chr(97+r)
        n//=26
        n-=1
    print(ans[::-1])

main()

Solution (Python):
import sys
import string

sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
from math import floor, sqrt, factorial, hypot, log  
from heapq import heappop, heappush, heappushpop
from collections import Counter, defaultdict, deque
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement
from bisect import bisect_left, bisect_right
from copy import deepcopy
from fractions import gcd
from random import randint


def ceil(a, b): return (a + b - 1) // b


inf = float('inf')
mod = 10 ** 9 + 7


def pprint(*A):
    for a in A:     print(*a, sep='\n')


def INT_(n): return int(n) - 1


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


def MF(): return map(float, input().split())


def MI_(): return map(INT_, input().split())


def LI(): return list(MI())


def LI_(): return [int(x) - 1 for x in input().split()]


def LF(): return list(MF())


def LIN(n: int): return [I() for _ in range(n)]


def LLIN(n: int): return [LI() for _ in range(n)]


def LLIN_(n: int): return [LI_() for _ in range(n)]


def LLI(): return [list(map(int, l.split())) for l in input()]


def I(): return int(input())


def F(): return float(input())


def ST(): return input().replace('\n', '')


def main():
    N = I()
    ans = []
    alpha = string.ascii_lowercase
    while N:
        ans.append(alpha[(N-1)%26])
        if N % 26 == 0:
            N = N // 26 - 1
        else:
            N = N // 26
    ans.reverse()
    answ = ""
    for a in ans:
        answ += a
    print(answ)



if __name__ == '__main__':
    main()

Solution (Python):
N=int(input())
ans=""
while N > 0:
    if N % 26 == 0:
        ans = "z" + ans
        N-=1
    else:
        ans = chr(N % 26 + 96) + ans
    N //= 26
    
print(ans)

Solution (Python):
n = int(input())
ans = ""
while n > 0:
    n, remainder = divmod(n - 1, 26)
    ans = chr(65 + remainder) + ans
print(ans.lower())

Solution (Python):
n=int(input())
from string import ascii_lowercase as S
ans=""
d={(i+1)%26:S[i] for i in range(26)}

while n:
    ans+=d[n%26]
    if n%26:
        n//=26
    else:n=n//26-1

print(ans[::-1])

Solution (Python):
import sys
import math

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"]
result = []

def alphabet_decimal(v):
    quotient = math.floor(v / len(ALPHABET))
    surplus = v % len(ALPHABET)
    quotient -= 1 if surplus == 0 else 0
    surplus = len(ALPHABET) if surplus == 0 else surplus
    result.append(surplus)
    if len(ALPHABET) < quotient:
        alphabet_decimal(quotient)
    elif len(ALPHABET) < v:
        result.append(quotient)
    return "".join([ALPHABET[i - 1] for i in reversed(result)])

n = int(input())
print(str.lower(alphabet_decimal(n)))

Solution (Python):
N = int(input())
s = ""
while True:
    a = N//26
    b = N%26
    if b == 0:
        b += 26
        a -= 1
    if a == 0:
        s += chr(b+96)
        break
    s += chr(b+96)
    N = a
rslt = s[::-1]
print(rslt)

Solution (Python):
N = int(input())
s = [100] * 15
k = 0
for i in range (15):
    if N == 0:
        break
    s[i] = N%26
    N = (N - 1)//26
    k += 1
for i in range(k):
    if s[i] == 0:
        s[i] = 122
    else:
        s[i] = s[i] + 96
for i in range(k):
    print(chr(s[k - 1 - i]),end = "")
print()

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

S = num2alpha(N)
print(S.lower())

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

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)

ans = num2alpha(n)

print(ans.lower())

Solution (Python):

def solve(N):
    if N== 0:
        return ""
    if N == 1:
        return 'a'
    N -= 1
    A = 'abcdefghijklmnopqrstuvwxyz'
    N, r = divmod(N, 26)
    return solve(N) + A[r]
N = int(input())
print(solve(N))

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

rlt = ""

while N > -1:
  rlt = chr(ord("a")+N%26) + rlt
  N = N//26 - 1
  
print(rlt)

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

q, mod = divmod(N, 26)
if mod == 0:
    ans = "z"
    q -= 1
else:
    ans = chr(mod+96)

while q > 0:
    q, mod = divmod(q, 26)
    if mod == 0:
        ans = "z" + ans
        q -= 1
    else:
        ans = chr(mod+96) + ans
    
print(ans)

Solution (Python):
from collections import defaultdict,deque
from sys import stdin,setrecursionlimit
import heapq,bisect,math,itertools,string,queue,datetime,copy
setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inpl(): return list(map(int, stdin.readline().split()))

num2alpha = lambda c: chr(c+64)

N = int(input())

anls = []
while N >= 1:
    ch = N%26
    if ch ==0:
        ch = 26
    anls.append(num2alpha(ch).lower())
    N = int((N-ch)/26)
anls = anls[::-1]
print(''.join(anls))

Solution (Python):
N = int(input())-1
ans = []
while N>=0:
    x = N%26
    N //= 26
    N -= 1
    ans.append(chr(97+x))
print(''.join(ans[::-1]))

Solution (Python):
import sys
from io import StringIO
import unittest
import os


sys.setrecursionlimit(999999999)

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)


def resolve(test_def_name=""):
    
    
    
    
    
    

    
    
    

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



class TestClass(unittest.TestCase):
    def assertIO(self, assert_input, output):
        stdout, sat_in = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(assert_input)
        resolve(sys._getframe().f_back.f_code.co_name)
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, sat_in
        self.assertEqual(out, output)

    def test_input_1(self):
        test_input = """2"""
        output = """b"""
        self.assertIO(test_input, output)

    def test_input_2(self):
        test_input = """27"""
        output = """aa"""
        self.assertIO(test_input, output)

    def test_input_3(self):
        test_input = """123456789"""
        output = """jjddja"""
        self.assertIO(test_input, output)

    
    def tes_t_1original_1(self):
        test_input = """データ"""
        output = """データ"""
        self.assertIO(test_input, output)



if __name__ == "__main__":
    if os.environ.get("USERNAME") is None:
        
        resolve()

    else:
        
        unittest.main()

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

x = 26
c = 0
while N >= x :
  N -= x
  x *= 26
  c += 1

ret = []
while c >= 0 :
  y = N % 26
  N //= 26
  c -= 1
  ret.append(chr(ord('a') + y)) 

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

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

ans=num2alpha(N)
ans=ans.lower()

print(ans)

Solution (Python):
N = int(input())-1
C = "abcdefghijklmnopqrstuvwxyz"
k = len(C)
c = 1
while N >= k**c:
    N -= k**c
    c += 1
s = ""
while c > 0:
    s = s+C[N//(k**(c-1))]
    N = N % (k**(c-1))
    c -= 1
print(s)

Solution (Python):
n=int(input())
ans=""
ns=[25]
for i in range(25):
    ns.append(i)
while n!=0:
    ans=chr(ord('a')+ns[n%26])+ans
    n=(n-1)//26
print(ans)