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

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

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

Submission status: Wrong Answer

Solution code:
#float型を許すな
#numpyはpythonで
#dp
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi,factorial
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7

alphasm=[chr(i) for i in range(97, 97+26)]
n=I()
s=""
while n>0:
    x=n%26
    s+=alphasm[(x-1)%26]
    n=(n-x)//26
u=list(reversed(s))
print("".join(u))
#for i in range(15):
# print(26**i)

Submission status: Wrong Answer

Solution code:
n=int(input())
import math
k=math.ceil(math.log(n,26))
s=""
al=["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']
for i in range(k):
  s=al[n%26]+s
  n=n//26
print(s)

Submission status: Wrong Answer

Solution code:
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):
        # アルファベット小文字 → (97, 123)
        # アルファベット大文字 → (65, 91)
        # 半角数字 → (48, 58)
        # ひらがな → (12353, 12436)
        # カタカナ → (12449, 12532+1)
        # 全角数字 → (65296, 65306)
        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)
        ans += al[check]
        if n == 0:
            print(ans[::-1])
            break


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
n= int(input())
ans=''

while n>0:
    if n%26==0:
        x=26
    else:
        x=n%26
    ans+=chr(96+x)
    n//=26
print(ans[::-1])

Submission status: Wrong Answer

Solution code:
N=int(input())

def Base_10_to_n(X, n):
    X_dumy = X
    out = ''
    while X_dumy>0:
        out = chr(96+X_dumy%n)+out
        X_dumy = int(X_dumy/n)
    return out

print(Base_10_to_n(N,26))

Submission status: Wrong Answer

Solution code:
N = int(input())

bit = []

for i in range(16):
    bit.append(N % 26)
    N //= 26

appear = False
res = ""
for b in bit[::-1]:
    if (not appear) and b != 0:
        appear = True
    if appear:
        res = res + chr(ord("a")+b-1)

print(res)

Submission status: Wrong Answer

Solution code:
N = int(input())
lis = []
while N > 26:
    lis.append(N % 26)
    N //= 26
lis.append(N)
for i in range(len(lis)):
    lis[i] = chr(lis[i]+ord('a')-1)
lis.reverse()
print(''.join(lis))

Submission status: Wrong Answer

Solution code:
n = int(input())
lis = []
while n != 0:
    if n%26 == 0:
        lis.append(int(0))
        n /= 26
    else:
        lis.append(int(n%26))
        n -= n%26
        n /= 26
alp = ["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"]
st = ""
for i in range(len(lis),0,-1):
    st += alp[lis[i-1]]
print(st)

Submission status: Wrong Answer

Solution code:
# coding: utf-8
L = []
def Base_10_to_n(X, n):
    if (int(X/n)):
        L.append(str(X%n))
        return Base_10_to_n(int(X/n), n)
    return L + [str(X%n)]
N = int(input())
S = "abcdefghijklmnopqrstuvwxyz"
V = Base_10_to_n(N, 26)
V.reverse()
ans = ""
for i in range(len(V)):
    ans += S[int(V[i])-1]
print(ans)

Submission status: Wrong Answer

Solution code:
N = int(input())
alphabet = list('abcdefghijklmnopqrstuvwxyz')
ans = ''
while N != 0:
    ans = alphabet[N%26 - 1] + ans
    N = N//26
print(ans)

Submission status: Wrong Answer

Solution code:
def resolve():
    n = int(input())
    flag = 0
    name = []
    while n > 0:
        c = n % 26
        name.append(c)
        n //= 26
        if n == 1:
            flag = 1

    print(''.join([chr(i + 96) for i in reversed(name)]))

resolve()

Submission status: Wrong Answer

Solution code:
N = int(input())
A = [chr(i) for i in range(ord('a'), ord('z') + 1)]
t = ''
if N < 26:
    print(A[N - 1])
    exit()

while True:
    t += A[N % 26 - 1]
    N //= 26
    if N < 26:
        t += A[N - 1]
        break

print(t[::-1])

Submission status: Wrong Answer

Solution code:
n = int(input())
ans = ''
while n>0:
    ama = n%26
    n = (n-ama)//26
    
    if ama==0:
        ama=26
    ans = chr(96+ama) + ans

print(ans)

Submission status: Wrong Answer

Solution code:
from string import ascii_lowercase as alph
N = int(input())
A = list(alph)

ans = []

def sol(n):
    global ans
    if n == 0:
        return
    q, r = divmod(n, 26)
    ans.append(A[r - 1])
    sol(q)

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

Submission status: Wrong Answer

Solution code:
import string

N = int(input())
n = N
xs = []
while 0 < n:
    r = (n - 1) % 26
    xs.append(string.ascii_lowercase[r])
    n //= 26
print(''.join(reversed(xs)))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

left = 0
right = 100
while left+1 < right:
    mid = (left + right) // 2
    if 26**mid <= n:
        left = mid
    else:
        right = mid

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

print(ans)

Submission status: Wrong Answer

Solution code:
n = int(input())

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

ans = ''
while n > 0:
    ans = char(n % 26) + ans
    n //= 26

print(ans)

Submission status: Wrong Answer

Solution code:
# -*- coding: utf-8 -*-
alphabet = 'abcdefghijklmnopqrstuvwxyz'
N = int(input())

n = N
name = []
while n != 0:
    name.append(alphabet[(n%26)-1])
    n = int(n/26)

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

Submission status: Wrong Answer

Solution code:
N = int(input())

ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ans = []
c = 0
while N>0:
    n = N%26
    ans.append(n)
    N //= 26

ans.reverse()
o = []
for a in ans:
    s = ascii_lowercase[a-1]
    o.append(s)

print(''.join(o))

Submission status: Wrong Answer

Solution code:
al = ['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']
N = int(input())
tmp = 26
ans = ''
while True:
    ans += al[N%26-1]
    N = N // tmp
    if N == 0:
        break
print(ans[::-1])

Submission status: Wrong Answer

Solution code:
n=int(input())-1
lst=[]
while n:
    lst.append(n%26)
    n//=26
for i in range(1,len(lst)):
    lst[i]-=1
print(''.join([chr(i+97) for i in lst][::-1]))

Submission status: Wrong Answer

Solution code:
N = int(input())

bit = []

for i in range(11):
    bit.append(N % 26)
    N //= 26

appear = False
res = ""
for b in bit[::-1]:
    if (not appear) and b != 0:
        appear = True
    if appear:
        res = res + chr(ord("a")+b-1)

print(res)

Submission status: Wrong Answer

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

import sys
sys.setrecursionlimit(300000)


def solve(N: int):
    ret = []
    while N > 0:
        tmp = N % 26
        ret.append(chr(ord('a') + tmp - 1))
        N //= 26
    ret.reverse()
    ret = ''.join(ret)
    print(ret)
    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())
x = 26
i = 1
ans = []
while n != 0:
    ans.append(chr(ord("a") + n % x - 1))
    n //= x

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

Submission status: Wrong Answer

Solution code:
N = int(input())
name = []

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

name.reverse()
print("".join(name))

Submission status: Wrong Answer

Solution code:
from sys import stdin
from sys import setrecursionlimit
setrecursionlimit(10 ** 7)
from string import ascii_lowercase

alpha = "1"+ascii_lowercase
n = int(input())

li = []

def Base_10_to_n(X, n):
    if (int(X/n)):
        li.append(X%n)
        return Base_10_to_n(int(X/n), n)+str(X%n)
    li.append(X%n)
    return str(X%n)


sin = Base_10_to_n(n,26)
li = li[::-1]

s = ""

for i in li:
    s += alpha[int(i)]

print(s)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
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()
crr=[chr(97 + i) for i in range(26)]

res = []
while N:
    res.append(crr[N%26-1])
    N //= 26
res.reverse()
print("".join(res))

Submission status: Wrong Answer

Solution code:
n=int(input())


b = 26
while True:
    if n <= b:
        break
    else:
        b*=26

b = b/26
while True:
    t = int(n/b) + 96
    print(chr(t),end='')
    n = n%b
    b = b/26
    if b < 1:
        break

print()

Submission status: Wrong Answer

Solution code:
n = int(input())
name = ""
while(n%26 > 0):
	r = n % 26
	n = n // 26
	name = chr(r+96) + name
print(name)

Submission status: Wrong Answer

Solution code:
N = int(input())

count = 1
num = []

while 1:
  if N // 26 != 0:
    count += 1
    num.append(N % 26)
    N //= 26
  else:
  	num.append(N % 26)
  	break
  	
ans = ''
  	
for i in range(len(num)):
  ans += chr(96 + num[i])
  
print(ans[::-1])

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
n = int(input())
ans = ''
while n:
  ans = chr((n-1)%26+ord('a')) + ans
  n //= 26
print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
# coding: utf-8
N=int(input())

num_a=ord("a")

ans=""

X_dumy = N
while X_dumy>0:
    out = X_dumy%26
    X_dumy = int(X_dumy/26)
    ans=chr(num_a+out-1)+ans

print(ans)

Submission status: Wrong Answer

Solution code:
# coding: utf-8
import sys
from math import log

stdin = sys.stdin
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))


def main():
    ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
    n = ni()
    m = int(log(n,26))
    ans = ''
    for i in range(m+1):
        ans += ascii_lowercase[n%26-1]
        n //= 26
    print(ans[::-1])
    return


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import heapq

n = int(input())

s = []
while (n != 0):
    temp = n % 26
    if(temp == 0):
        temp = 26
    s.append(chr(temp + 96))
    n = (n - n % 26) // 26

s.reverse()
s = "".join(s)
print(s)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import string
n = int(input())

al = '_'+string.ascii_lowercase

ans = ''
while True:
  ans = al[n%26] + ans
  n //= 26
  if n==0:
    break
  
print(ans)

Submission status: Wrong Answer

Solution code:
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
    anls.append(num2alpha(ch).lower())
    N = int((N-ch)/26)
anls = anls[::-1]
print(''.join(anls))

Submission status: Wrong Answer

Solution code:
ALPHA = 'abcdefghijklmnopqrstuvwxyz'
N = int(input())
ans = ''
while N:
    N, r = divmod(N, 26)
    ans += ALPHA[(r - 1) % 26]
print(ans[::-1])

Submission status: Wrong Answer

Solution code:
N=int(input())
ans=''
while N>0:
  n=N%26
  n=(n+26)%27
  N=N//26
  ans=chr(n+97)+ans
  if N==0:
    break
print(ans)

Submission status: Wrong Answer

Solution code:
import math


def h(n):

    p = int(math.log(n, 26))
    # return int(pow(2, p));
    return p+1


def DecimalToBinary(num):

    if num > 25:
        DecimalToBinary(num // 26)
    print(num % 2, end='')


n = int(input())
# print(h(27))
n_let = h(n)
ans = []
while(n):
    # ans = str(n % 26)+ans
    ans.append(n % 26)
    n = n//26
# print(ans)
res = ""
for i in ans:
    res = chr(ord('a')+i-1)+res
print(res)

Submission status: Wrong Answer

Solution code:
N = int(input())

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

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

Submission status: Wrong Answer

Solution code:
MOD=10**9+1
n=int(input())
ans=''
while n:
    ans=chr(ord('a')+n%26-1)+ans
    n//=26
print(ans)

Submission status: Wrong Answer

Solution code:
from pprint import pprint
import sys

N = int(sys.stdin.readline().strip())

ans = ""
while N:
    pos = N % 26
    char = chr(ord("a") + pos - 1)    
    ans = char + ans
    N = N // 26

print(ans)

Submission status: Wrong Answer

Solution code:
n=int(input())  #96
a=""
while n>0:
    rem=n%26
    if rem==0:
        a+="z"
    else:
        a+=chr(96+rem)
    n=n//26

print(a[::-1])

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import string
k=list(string.ascii_lowercase)
n=int(input())
l=[]
while n>0:
  l.append(n%26)
  n=n//26
l.reverse()
x=""
for i in l:
  x+=k[i-1]
print(x)

Submission status: Wrong Answer

Solution code:
import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal
from collections import defaultdict

# import fractions

sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)
# lcm = lambda x, y: (x * y) // fractions.gcd(x, y)

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


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    N = ii()
    d, m = divmod(N, 26)
    if d == 0:
        print(chr(96 + m))
        exit()

    S = chr(96 + m)
    while d >= 26:
        d, m = divmod(d, 26)
        S = chr(96 + m) + S

    print(chr(96 + d) + S)


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
def main():
    from sys import setrecursionlimit, stdin, stderr
    from os import environ
    from collections import defaultdict, deque, Counter
    from math import ceil, floor
    from itertools import accumulate, combinations, combinations_with_replacement
    setrecursionlimit(10**6)
    dbg = (lambda *something: stderr.write("\033[92m{}\033[0m".format(str(something)+'\n'))) if 'TERM_PROGRAM' in environ else lambda *x: 0
    input = lambda: stdin.readline().rstrip()
    LMIIS = lambda: list(map(int,input().split()))
    II = lambda: int(input())
    P = 10**9+7
    INF = 10**18+10

    N = II()
    ans = ''
    while N > 0:
        ans = chr(ord('a')+((N+25) % 26)) + ans
        N //= 26
    print(ans) 
    
main()

Submission status: Wrong Answer

Solution code:
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())
#N, M = map(int, input().split())
#A = list(map(int, input().split()))
#A = [int(input()) for _ in range(N)]
#ABC = [list(map(int, input().split())) for _ in range(N)]

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

Submission status: Wrong Answer

Solution code:
n=int(input())
s=''
while n!=0:
    n,v=divmod(n,26)
    s+=chr(96+v)
print(s[::-1])

Submission status: Wrong Answer

Solution code:
N = int(input())


def n2a(n):
    if n == 0:
        return "z"
    n += 96
    return chr(n)


res = ""
while N > 0:
    t = N % 26
    res = n2a(t) + res
    N //= 26

print(res)

Submission status: Wrong Answer

Solution code:
n = int(input())

s = ""
while n!=0:
  s += chr(n%26+96)
  n = n//26
  
print(s[::-1])

Submission status: Wrong Answer

Solution code:
def main():
    import sys
    sys.setrecursionlimit(10**9)
    input = sys.stdin.readline

    N = int(input())
    a = "0abcdefghijklmnopqrstuvwxyz"
    ans = []

    while N != 0:
        ans.append(a[N % 26])
        N //= 26
    
    ans.reverse()
    print(''.join(ans))

main()

Submission status: Wrong Answer

Solution code:
#

import sys
input=sys.stdin.readline

def main():
    N=int(input())
    st=[]
    n=26
    for i in range(1,1000000):
        if N%n==0:
            st.append("z")
        else:
            st.append(chr(N%n+ord("a")-1))
        N=int(N//n)
        if N<=1:
            break
    st=st[::-1]
    print("".join(st))
    
    
    
if __name__=="__main__":
    main()

Submission status: Wrong Answer

Solution code:
from collections import deque
#S = deque(['x', 'y'])
#print(S)   ->   deque(['x', 'y'])
#popleft  ->  キュー
#pop  ->  スタック

N = int(input())
ans = deque([])

while True:
    N, mod = N//26, N%26
    ans.append(mod)
    if N==0:
        break

while ans:
    mod = chr(ans.pop() + 96)
    print(mod, end='')

Submission status: Wrong Answer

Solution code:
def main():
    #N,K=map(int,input().split())
    #p=list(map(int,input().split()))
    N=int(input())
    ans=""
    while N!=0:
        tmp=N%26
        N//=26
        ans=chr(tmp-1+ord("a"))+ans
    print(ans)


main()

Submission status: Wrong Answer

Solution code:
def resolve():
    n=int(input())
    abcd = 'abcdefghijklmnopqrstuvwxyz'
    s=""
    while n<=26:
        s=abcd[(n%26)-1]+s
        n=n//26
        if n<=26:
            break
    print(s)
resolve()

Submission status: Wrong Answer

Solution code:
import sys
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(rs())
def rs_(): return [_ for _ in rs().split()]
def ri_(): return [int(_) for _ in rs().split()]

N = ri()
abc = 'abcdefghijklmnopqrstuvwxyz'
ans = ''
while N > 0:
    ans = abc[N % 26 - 1] + ans
    N = N // 26
print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
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())

c=26
"""
while N>=c:

    N-=c
    c*=26
"""
lst=[]
while N:
    a=N%26
    lst.append(a)
    N//=26
#print(lst)
lst.reverse()
#lst[-1]
S="".join([chr(i+ord("a")-1) for i in lst])
print(S)
#print(N,c,a)

Submission status: Wrong Answer

Solution code:
n = int(input())

alpha = 'abcdefghijklmnopqrstuvwxyz'

out = ''
while n != 0:
    out = alpha[(n % 26) - 1] + out
    n = int(n // 26)
print(out)

Submission status: Wrong Answer

Solution code:
n=int(input())

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

while True:
    ans.append(alpha[n%26-1])
    if n//26==0:
        break
    else:
        n//=26

print("".join(reversed(ans)))

Submission status: Wrong Answer

Solution code:
N=int(input())
alf = ['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=[]

while(N>0):
  ans.append(alf[N%26-1])
  N = N//26
ans.reverse()
print(*ans,sep='')

Submission status: Wrong Answer

Solution code:
N = int(input())
ans = ""
al = ['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(True):
  if N < 26:
    ans = al[N-1] + ans
    break
  tmp = N%26
  ans = al[tmp-1] + ans
  N = N//26
print(ans)

Submission status: Wrong Answer

Solution code:
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))

#1000000000000001
alpha = 'abcdefghijklmnopqrstuvwxyz'
n = ii()
tmp = n
ans = ''
while tmp > 26:
    ans += alpha[tmp%26-1]
    tmp //= 26

ans += alpha[tmp%26-1]
print(ans[::-1])

Submission status: Wrong Answer

Solution code:
n = int(input())
ans = []
while n > 0:
    ans.append(chr(96 + (n % 26)))
    n //= 26
print(*ans[::-1], sep = '')

Submission status: Wrong Answer

Solution code:
n = int(input())
ans = ''
m = ord('a') - 1
x = 0
while n >= 26 ** x:
    x += 1

while n != 0:
    x -= 1
    tmp = n // (26 ** x)
    ans = ans + chr(m + tmp)
    n -= tmp * (26 ** x)
print(ans)

Submission status: Wrong Answer

Solution code:
N = int(input())

ans = ''
while N > 0:
  ans = chr((N-1)%26+97) + ans
  N //= 26
print(ans)

Submission status: Wrong Answer

Solution code:
N=int(input())
alp='abcdefghijklmnopqrstuvwxyz'
K=0
while 26**K<N:
  K+=1
  
ans=''
N-=1
for i in range(K-1, 0, -1):
  x=N//(26**i)
  ans+=alp[x-1]
  N-=26**i*x
ans+=alp[N]
  
print(ans)

Submission status: Wrong Answer

Solution code:
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']

ans = ''
while True:
    # print(n)
    # print(n % 26)
    ans += alphabet[n % 26 - 1]
    n -= n % 26
    n = n // 26
    if n == 0:
        break

print(ans[::-1])

Submission status: Wrong Answer

Solution code:
import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal
from collections import defaultdict

# import fractions

sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)
# lcm = lambda x, y: (x * y) // fractions.gcd(x, y)

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


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    N = ii()
    d, m = divmod(N, 26)
    if d == 0:
        print(chr(96 + m))
        exit()

    S = chr(96 + m)
    while d > 26:
        d, m = divmod(d, 26)
        S = chr(96 + m) + S

    print(chr(96 + d) + S)


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
n = int(input())
a = ""
c = 0
for i in range(12):
    n1 = n//(26**(11-i))
    n = n % (26**(11-i))
    if n1 != 0 or c == 1:
        n2 = chr(97+n1-1)
        a += str(n2)
        c = 1
print(a)

Submission status: Wrong Answer

Solution code:
n = int(input())

l = []

while n > 0:
    n, r = divmod(n, 26)
    l.append(r)

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

f = ''

for i in range(len(l)):
    if l[len(l)-1-i] == 0:
        f += 'z'
    else:
        f += alpha[l[len(l)-1-i]-1]

print(f)

Submission status: Wrong Answer

Solution code:
import sys
read = sys.stdin.read
readline = sys.stdin.buffer.readline
INF = float('inf')


def main():
    N = int(readline())
    alphabet = 'zabcdefghijklmnopqrstuvwxyz'
    A = []
    ans = ''
    while N>0:
        ans = alphabet[N%26] + ans
        N//=26
    print(ans)

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
n = int(input())
alpha = [chr(x) for x in range(ord('a'), ord('z')+1)]
name = ''
while n:
  r = int(n%26)
  n = n // 26
  name += alpha[r-1]

print(name[::-1])

Submission status: Wrong Answer

Solution code:
n=int(input())
l=[chr(i) for i in range(97,123)]
#print(l)
ans=""
while True:
    x=n%26
    n=n//26
    ans+=l[x-1]
    if n==0:
        break
ans=ans[::-1]
print(ans)

Submission status: Wrong Answer

Solution code:
import bisect, collections, copy, heapq, itertools, math, numpy, string
import sys
from bisect import bisect_left, bisect_right, insort
from collections import deque
def S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
def MS(): return map(str, sys.stdin.readline().rstrip().split())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
# N = I()
# A = [LI() for _ in range(N)]


n = I()
s = 0
while 26**s <= n:
    s += 1
ans = ''
for i in range(s):
    k = n // 26**(s-i-1)
    ans = ans + chr(96 + k)
    n = n - k * 26**(s-i-1)
print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys

N_MAX = 200000 + 5
INF = 10**9 + 7
sys.setrecursionlimit(N_MAX)
MOD = 10**9 + 7

N = int(sys.stdin.readline())

alp = "abcdefghijklmnopqrstuvwxyz"


def name(A, s=""):
    i = A % 26
    z = alp[i - 1]
    s = z + s
    A = A // 26
    if A > 0:
        s = name(A, s)
    return s


print(name(N))

Submission status: Wrong Answer

Solution code:
N = int(input())

def Base_10_to_n(X, n):
    X_dumy = X
    out = []
    while X_dumy>0:
        out = [X_dumy%n]+out
        X_dumy = int(X_dumy/n)
    return out

N26 = Base_10_to_n(N, 26)
Alp = "abcdefghijklmnopqrstuvwxyz"
name = "".join([Alp[i-1] for i in N26])
print(name)

Submission status: Wrong Answer

Solution code:
n = int(input())
l = []
while n > 0:
    t = n // 26
    s = n % 26
    l.append(chr(96+s))
    n = t
l.reverse()
print(''.join(l))

Submission status: Wrong Answer

Solution code:
n = int(input())

ans = ""
while n > 0:
    x, y = divmod(n, 26)
    ans = ans + chr(y + 96)
    n //= 26
print(ans[::-1])

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
import collections
import itertools as it
import math
#import numpy as np
 
#  = input()
n  = int(input())
#  = map(int, input().split())
#  = list(map(int, input().split()))
#  = [int(input()) for i in range(N)]
#
# c = collections.Counter()

L = ['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']

s = ''
for i in range(int(math.log(n, 26)) + 1):
    #print(L[n % 26])
    s = L[n % 26] + s
    n = n // 26

print(s)

Submission status: Wrong Answer

Solution code:
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"]
N = int(input())
shou = N
ans = ""
while shou > 0:
    ans += alphabet[shou % 26 - 1]
    shou //= 26
print(ans[::-1])

Submission status: Wrong Answer

Solution code:
N = int(input())
alpha = list('abcdefghijklmnopqrstuvwxyz')
ans = ''

while N:
    n = (N % 26) - 1
    ans += alpha[n]
    N //= 26

print(ans[::-1])

Submission status: Wrong Answer

Solution code:
import string
characters = '0'+string.ascii_letters
 
def base_cvt(value, n=2):
    try:
        tmp = int(value)
    except:
        raise ValueError('Invalid value:', value)
 
    if n < 2 or n > len(characters):
        raise ValueError('Invalid n:', value)
 
    result = ''
    tmp = int(value)
    while tmp >= n:
        idx = tmp%n
        result = characters[idx] + result
        tmp = int(tmp / n)
    idx = tmp%n
    result = characters[idx] + result
    return result

N = int(input())
print(base_cvt(N,26))

Submission status: Wrong Answer

Solution code:
N = int(input())

ans=""
while N>1:
    r=(N+26-1)%26
    ans+=chr(ord("a")+r)
    N//=26
print("".join(reversed(ans)))