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:
#!/usr/bin/env python3
import bisect
import collections
import sys

sys.setrecursionlimit(1000000)
ACMOD = 1000000007
INF = 1 << 62


def solve(N: int):
    base = 26
    # z 26
    # aa 27
    # ab 28
    N -= 1
    rans = []
    for i in range(100):
        if N == 0:
            break
        if i == 0:
            rans.append(chr(N % base + ord('a')))
            N = N // base
        else:
            rans.append(chr((N-1) % base + ord('a')))
            N = N// base
    print("".join(reversed(rans)))
    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))  # type: int
    solve(N)


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
N = int(input())
name = ''
while N != 0:
    name = chr(ord('a') + N % 26 - 1)+name
    N = N // 26
print(name)

Submission status: Wrong Answer

Solution code:
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
    n = n//26

print(ans)

Submission status: Wrong Answer

Solution code:
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)
INF = float('inf')

N = int(input())
komoji = [chr(i) for i in range(97, 97+26)]

ans = ""
while True:
    q, mod = divmod(N, 26)
    ans += komoji[mod-1]
    N = q
    if q == 0:
        break
ans = "".join(reversed(ans))
print(ans)

Submission status: Wrong Answer

Solution code:
n = int(input())
alp = ' abcdefghijklmnopqrstuvwxyz'

ans = ''

while n > 0:
    x = n % 26
    ans = alp[x] + ans

    n //= 26

print(ans)

Submission status: Wrong Answer

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


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


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

Submission status: Wrong Answer

Solution code:
"""
~~ Author : Bhaskar
~~ Dated : 10~06~2020
"""

import sys
from bisect import *
from math import floor,sqrt,ceil,factorial as F,gcd,pi
from itertools import chain,combinations,permutations,accumulate
from collections import Counter,defaultdict,OrderedDict,deque
from array import array
INT_MAX = sys.maxsize
INT_MIN = -(sys.maxsize)-1
mod = 1000000007
ch = "abcdefghijklmnopqrstuvwxyz"
lcm = lambda a,b : (a*b)//gcd(a,b)
setbit = lambda x : bin(x)[2:].count("1")
input = lambda : sys.stdin.readline()

def solve():
    n = int(sys.stdin.readline())
    # print(n%26)
    ans = ""
    while n > 0:
        ans += ch[(n % 26) - 1]
        n //= 26
    print(ans[::-1])


if __name__ == "__main__":
    try:
        sys.stdin = open('input.txt','r')
        sys.stdout = open('output.txt','w')
    except:
       pass
    solve()

Submission status: Wrong Answer

Solution code:
ans = []
n = int(input())
while n!= 0:
    ans.append(chr(n%26+96))
    n //= 26
ans.reverse()
print("".join(ans))

Submission status: Wrong Answer

Solution code:
from math import *
from bisect import bisect_left

def cin(): # To take limited number of inputs
    return map(int,input().split())

def cins(): # To take space sepreated strings
    return input.split()

def cino(test=False): # To take individual int input (test = False)
    if not test:
        return int(input())
    else: # To take string input (test = True)
        return input()

def cina(): # array input
  return list(map(int,input().split()))

def ssplit(): # multiple string input
    return list(input().split())

def printlist(l): # To print space seperated array
    for i in l:
        print(i,end=" ")

def bs(arr, l, r, x): 
    while l <= r: 
        mid = l + (r - l) // 2; 
        if arr[mid] == x: 
            return mid 
        elif arr[mid] < x: 
            l = mid + 1
        else: 
            r = mid - 1
    return -1


def main():
    arr = ['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 = cino()
    s = ""
    while a!=0:
        temp = a%26
        s += arr[temp-1]
        a = a//26
    print(s[::-1])





if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
# coding: utf-8
import sys
# from operator import itemgetter
sysread = sys.stdin.readline
read = sys.stdin.read
sys.setrecursionlimit(10 ** 7)
#from heapq import heappop, heappush
#from collections import OrderedDict, defaultdict
#import math
#from itertools import product, accumulate, combinations, product
#import bisect# lower_bound etc
#import numpy as np
# from copy import deepcopy
#from collections import deque
#import numba

def run():
    dict = 'zabcdefghijklmnopqrstuvwxy'
    ret = ''
    N = int(input())
    while N:
        tmp = N % 26
        N = N // 26
        ret = dict[tmp] + ret
    print(ret)
if __name__ == "__main__":
    run()

Submission status: Wrong Answer

Solution code:
n = int(input())
al=[chr(ord('a') + i) for i in range(25)]
al=['z']+al
ans=''
while n>0:
    ans=al[n%26]+ans
    n//=26
print(ans)

Submission status: Wrong Answer

Solution code:
########関数部分##############
def Base_10_to_26(X):
    if (int(X/26)):
        return Base_10_to_26(int(X/26))+chr((X%26)+96)
    return chr((X%26)+96)
############################

N=int(input())
print(Base_10_to_26(N))

Submission status: Wrong Answer

Solution code:
n = int(input())


ans = []
while n > 0:
    n, y = divmod(n, 26)
    ans.append(y)
ans.reverse()


def to_alpha(x):
    if x == 0:
        return 'z'
    else:
        return chr(x+ord('a')-1)


print(''.join(map(to_alpha, ans)))

Submission status: Wrong Answer

Solution code:
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from collections import Counter # a = Counter(A).most_common()
#from itertools import accumulate #list(accumulate(A))
import string

N = ii()
alpha = [chr(i) for i in range(97, 97+26)]
'''
alpha = [chr(i) for i in range(97, 97+26)]
if 0 <= N <= 25:
    print(alpha[i])
elif 26<= N <= 702:
'''
ans = ''
a = float('inf')
while a >0:
    N, a = N//26, N %26
    if a > 0:
        ans += alpha[a-1]

print(ans[::-1])

Submission status: Wrong Answer

Solution code:
N = int(input())
alphabet = [
    "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"]
out = []
div = 28


while True:
    N, mod = divmod(N, 26)
    out.append(alphabet[mod])
    if N == 0:
        break
print("".join(reversed(out)))

Submission status: Wrong Answer

Solution code:
num_to_alpha = "zabcdefghijklmnopqrstuvwxy"

n = int(input())

ans = []
while n:
    num = n % 26
    ans.append(num_to_alpha[num])
    n //= 26

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

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
ALPHABET = "abcdefghijklmnopqrstuvwxyz"
n = int(input())
ans = ""
while n > 0:
    ans += ALPHABET[(n - 1) % 26]
    n //= 26
print(ans[::-1])

Submission status: Wrong Answer

Solution code:
def main():
    n = int(input())
    ans = ""
    for i in reversed(range(11)):
        x = 26**i
        if n >= x:
            y = n // x
            ans += chr(ord("a") + y - 1)
            n %= x
    print(ans)

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
n = int(input())
'''
#n = 26
now = 26
while True:
  if n - now <= 0:
    break
  else:
    n -= now
    now *= 26
print(n)
'''
ans = ''
while n:
  ans = chr(n%26+ord('a')-1) + ans
  n //= 26
print(ans)

Submission status: Wrong Answer

Solution code:
N=int(input())
s=""
while N>0:
    x=N%26
    if x==0:
        x=26
    N=N//26
    s=chr(96+x)+s
print(s)

Submission status: Wrong Answer

Solution code:
def resolve():
    n = int(input())
    log26 = []
    while n > 0:
        log26.append(n%26)
        n //= 26
    ans = []
    for i in reversed(range(len(log26))):
        ans.append(chr(log26[i]+96))
    print("".join(ans))
resolve()

Submission status: Wrong Answer

Solution code:
# /usr/bin/python3
# -*- coding: utf-8 -*-
from queue import Queue
from queue import LifoQueue as Stack
from math import sqrt, floor, ceil, log2, log10, pi
from fractions import gcd
from itertools import permutations, combinations
from operator import itemgetter
from functools import cmp_to_key


INF=1001001001
__MOD__=(10**9)+7
yn = 'YNeos'
judge = False
cnt = 0
ans = None


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

def intinput():
    return int(input())

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

def lineinputs(func=intinput):
    datas = []
    while True:
        try:
            datas.append(func())
        except EOFError:
            break
    return datas

class ModInt():
    def __init__(self, x):
        self.__x = (x % __MOD__)
    def __add__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x + other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x + other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __radd__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x + self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x + self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __sub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x - other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x - other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rsub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x - self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x - self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __mul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rmul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x * self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x * self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __truediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rtruediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x * self.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x * self.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __pow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(self.__x, other.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(self.__x, other.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")
    def __rpow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(other.__x, self.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(other.__x, self.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")

    def __modinv(self, m=__MOD__):
        a = self.__x
        if a == 0:
            raise ZeroDivisionError()
        if gcd(a, m) != 1:
            raise Exception("%sの逆数は求まりません。" % a)
        b, u, v = m, 1, 0
        while b != 0:
            t = a//b;
            a -= t*b
            a, b = b, a
            u -= t * v
            u, v = v, u
        u %= m
        if u < 0:
            u += m
        return u
    def __int__(self):
        return self.__x
    def __str__(self):
        return str(self.__x)



if __name__ == '__main__':
    N = intinput()

    # ord('a') 97
    ret = []
    while N > 0:
        n = N % 26
        ret.append(chr(97 + n-1))
        N = N // 26
    ret.reverse()
    print(''.join(ret))

Submission status: Wrong Answer

Solution code:
import sys

class alphabet: #Trueなら大文字
    def __init__(self, capitalize):
        self.num = dict() #アルファベットを数字に変換
        self.abc = ["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 capitalize: 
            for i in range(26): self.abc[i] = self.abc[i].upper()
        for i, a in enumerate(self.abc): self.num[a] = i


def solve():
    input = sys.stdin.readline
    N = int(input())
    AB = alphabet(False)
    Ans = ""
    while N > 26:
        Ans = AB.abc[N % 26 - 1] + Ans
        N //= 26
    Ans = AB.abc[N % 26 - 1] + Ans
    print(Ans)


    return 0

if __name__ == "__main__":
    solve()

Submission status: Wrong Answer

Solution code:
N = int(input())

res = []
while N > 0:
    res.append(N%26)
    N //= 26


print(*(chr(ord('a')+v-1) for v in reversed(res)), sep='')

Submission status: Wrong Answer

Solution code:
# abc171_c.py
N = int(input())
ans=[]
while N > 0:
    ans.append(N%26)
    N=N//26
alphabet = 'abcdefghijklmnopqrstuvwxyz'
ans = reversed(ans)
for i in ans:
    print(alphabet[i-1],end="")

Submission status: Wrong Answer

Solution code:
def f(N):
    F=1
    S=[]
    while F==1 or N>0:
        F=0
        S.append((N-1)%26)
        N//=26

    return S

N=int(input())
L=f(N)
M=list(map(lambda x:chr(ord("a")+x),L[::-1]))
print("".join(M))

Submission status: Wrong Answer

Solution code:
n = int(input())
ans = ""
while n > 0:
    if n < 26:
        ans += chr(97+n-1)
        break
    else:
        K = n%26
        ans += chr(97+K-1)
        n //= 26
print(ans[::-1])

Submission status: Wrong Answer

Solution code:
n = int(input())
ans = ''
while n != 0:
    s = n % 26
    ans += chr(s + 96)
    n //= 26
print(ans[::-1])

Submission status: Wrong Answer

Solution code:
n=int(input())

s=''
while n:
  n-=1
  s=chr(65+n%26)+s
  n//=26
  
print(s)

Submission status: Wrong Answer

Solution code:
N = int(input())
res = []
abc = "abcdefghijklmnopqrstuvwxyz"
alpha = 26

while N > 0:
    res.append(abc[N%alpha-1])
    N = N//alpha

print(*res[::-1],sep="")

Submission status: Wrong Answer

Solution code:
n = int(input())

s = ""
while n > 0:
    m = n % 26 - 1
    n = n // 26

    s = chr(ord('a') + m) + s

print(s)

Submission status: Wrong Answer

Solution code:

n=int(input())

l=[]
while n>0:
    a=n%26
    n//=26
    l.append(chr(96+a))
l.reverse()
ans=''.join(l)
print(ans)

Submission status: Wrong Answer

Solution code:
N = int(input())

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

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

Submission status: Wrong Answer

Solution code:
N = int(input())
a = 26
ans = ""
while(N):
    cur = N % a
    if(cur == 0): ans += 'z'
    else: ans += chr(ord('a') + cur - 1)
    N //= 26
ans = ans[::-1]
print(ans)

Submission status: Wrong Answer

Solution code:
N=int(input())
x=0
while 26**x<=N:
    x+=1
a=[0]*x
for i in range(x):
    a[i]=N//(26**(x-i-1))
    N%=(26**(x-i-1))
print(''.join([chr(c+ord('a')-1) for c in a]),sep='\n')

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from collections import deque
n = int(input())
d = deque()
while(n):
    d.append(chr(96+n%26))
    n //= 26

while d:
    print(d.pop(),end="")

Submission status: Wrong Answer

Solution code:
def main():
    N = int( input())
    t = 26
    ANS = []
    a = ord("a")-1
    while N > 0:
        ANS.append( chr(N%t+a))
        N //= t
    print("".join( ANS[::-1]))
if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
n = int(input())

buf = []
while True:
    if n > 26:
        tp = n%26
        buf.append(tp)
        n = n//26
    else:
        buf.append(n)
        break

# print(buf)
buf.reverse()

ans = ""
for b in buf:
    ans += chr(b+96)

print(ans)

Submission status: Wrong Answer

Solution code:
n=int(input())
l=[chr(ord('a') + i) for i in range(26)]
ans=''
while n:
  a = n%26
  ans+=l[a-1]
  n //= 26
ans = list(ans)
print(''.join(ans[::-1]))

Submission status: Wrong Answer

Solution code:
# -*- coding: utf-8 -*-
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
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
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
        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()

Submission status: Wrong Answer

Solution code:
import sys
sys.setrecursionlimit(10 ** 8)

def Z(): return int(input())
def ZZ(): return [int(_) for _ in input().split()]

def main():

    n = Z()
    ans = []
    while n > 0:
        n, b = divmod(n, 26)
        ans.append(chr(ord('a')+b-1))
    print(''.join(ans)[::-1])

    return

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import sys

sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inm = lambda: map(int, sys.stdin.readline().split())
inl = lambda: list(inm())
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print(*a, **kw, file=sys.stderr)

N = ini()


def solve():
    k = 26
    a = k
    l = 1
    name = []
    x = N

    while x > 0:
        c = x % 26
        name.append(chr((c + 25) % 26 + ord("a")))
        x //= 26
    return "".join(reversed(name))


print(solve())

Submission status: Wrong Answer

Solution code:
n = int(input())

res = []
while n > 0:
    if n % 26 == 0:
        res.append('z')
    else:
        res.append(chr(n % 26 + ord('a') - 1))
    n //= 26

for c in res[::-1]:
    print(c, end='')

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
n = int(input())
s = "abcdefghijklmnopqrstuvwxyz"
z = ""

while n:
    r = n % 26
    z += s[r-1] 
    n = n // 26

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

Submission status: Wrong Answer

Solution code:
n = int(input())
ans = []
while n > 0:
    p = n % 26
    p -= 1
    ans.append(chr(ord('a')+p))
    n //=26
ans.reverse()
print(''.join(ans))

Submission status: Wrong Answer

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


def solve(N: int):
    result = []
    while True:
        div = N // 26
        mod = N % 26
        result.append(mod)
        if div == 0:
            break
        else:
            N = div

    print(''.join([chr(x+ord('a')-1) for x in result][::-1]))
    return


# 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:
N = int(input())

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

print(''.join(reversed(buf)))

Submission status: Wrong Answer

Solution code:
N = int(input())
ans = ""
while(N > 0):
    temp = N % 26
    ans = chr(ord(chr(temp + 64)) + 32) + ans
    N = N // 26
print(ans)

Submission status: Wrong Answer

Solution code:
N=int(input())

ANS=""
while N:
    ANS+=chr(N%26+96)
    N//=26

print(ANS[::-1])

Submission status: Wrong Answer

Solution code:
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

N = int(input())
ans = []
char = ['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']

while N:
    i = N%26
    ans.append(char[i-1])
    N //= 26
print(''.join(ans[::-1]))