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:
# coding: utf-8
#import numpy as np
import re
import math
from collections import defaultdict
from collections import deque
import collections
from fractions import Fraction
import bisect
from queue import PriorityQueue
import itertools
from itertools import accumulate
from copy import deepcopy
from collections import Counter
import heapq
import random
import time
import os
import sys
import datetime
from functools import lru_cache
from functools import reduce
readline=sys.stdin.readline
sys.setrecursionlimit(2000000)
alphabet="abcdefghijklmnopqrstuvwxyz"
numbers="0123456789"
mod=int(10**9+7)
inf=int(10**19)
class Set():
    def __init__(self,A=[]):
        self.heap=[]
        self.dic=defaultdict(bool)
        self.size=0
        for a in A:self.add(a)
    
    def __str__(self):
        return str(self.heap)
    
    def add(self,x):
        if not self.find(x):
            heapq.heappush(self.heap,x)
            self.dic[x]=True
            self.size+=1

    def remove(self,x):
        if self.find(x):
            self.dic[x]=False
            self.size-=1

    def find(self,x):
        return self.dic[x]
    
    def top(self):
        while self.heap and self.dic[self.heap[0]]==False:
            heapq.heappop(self.heap)
        if self.heap:return self.heap[0]
        else:return None

    def pop(self):
        ret=None
        if self.heap:
            ret=self.top()
            self.remove(ret)
        return ret
class multiset():
    def __init__(self,A=[]):
        self.heap=[]
        self.dic=defaultdict(int)
        self.size=0
        for a in A:self.add(a)
    
    def __str__(self):
        return str(self.heap)
    
    def add(self,x):
        heapq.heappush(self.heap,x)
        self.dic[x]+=1
        self.size+=1

    def remove(self,x):
        if self.dic[x]>0:
            self.dic[x]-=1
            self.size-=1
    
    def count(self,x):
        return self.dic[x]

    def find(self,x):
        return self.dic[x]>0
    
    def top(self):
        while self.heap and self.dic[self.heap[0]]==0:
            heapq.heappop(self.heap)
        if self.heap:return self.heap[0]
        else:return None

    def pop(self):
        ret=None
        if self.heap:
            ret=self.top()
            self.remove(ret)
        return ret
class Edge():
    def __init__(self,x,y,val=1):
        self.x=x
        self.y=y
        self.val=val
class unionfind():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(n)]
        self.rank=[0]*n
 
    def find(self,x):
        if(x!=self.P[x]):
            self.P[x]=self.find(self.P[x])
        return self.P[x]
 
    def same(self,x,y):
        return self.find(x)==self.find(y)
 
    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1
 
    def unite(self,x,y):
        self.link(self.find(x),self.find(y))
 
    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S)
def yn(b):
    if b:print("yes")
    else:print("no")
def Yn(b):
    if b:print("Yes")
    else:print("No")
def YN(b):
    if b:print("YES")
    else:print("NO")
def ispow(a,b):
    now=b
    while now<a:
        now*=b
    return now==a
def getbin(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A
def getfacs(n,mod_=0):
    A=[1]*(n+1)
    for a in range(2,len(A)):
        A[a]=A[a-1]*a
        if(mod_>0):A[a]%=mod_
    return A
def comb(n,r,mod,fac):
    if(n-r<0):return 0
    return (fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod))%mod
def nextcomb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:return num
def getprimes(n):
    if n==0:return []
    A=[True]*(n+1)
    A[0]=False
    A[1]=False
    for a in range(2,n+1):
        if A[a]:
            for b in range(a*2,n+1,a):
                A[b]=False
    ret=[]
    for a in range(n+1):
        if(A[a]):ret.append(a)
    return ret
def isprime(num):
    if(num<=1):return False
    i=2
    while i*i<=num:
       if(num%i==0):return False
       i+=1
    return True
def ifelse(bbool,ret1,ret2):
    if bbool:return ret1
    else:return  ret2
def factorize(n):
    b = 2
    ret=defaultdict(int)
    while b * b <= n:
        while n % b == 0:
            n //= b
            ret[b]+=1
        b+=1
    if n > 1:ret[n]+=1
    return ret
def pm(x):
    return x//abs(x)
def inputintlist(): 
    return list(map(int,input().split()))
def inputfloatlist(): 
    return list(map(float,input().split()))
def istanchouzouka(A):
    f=True
    prev=min(A)-1
    for a in A:
        if prev>=a:
            f=False
        prev=a
    return f
def istanchouhigensyou(A):
    f=True
    prev=min(A)-1
    for a in A:
        if prev>a:
            f=False
        prev=a
    return f
def getallsum(A):
    s=sum(A)
    dp=defaultdict(int)
    dp[0]=1
    for a in range(0,len(A)):
        for b in range(s,-1,-1):
            if b-A[a]>=0:
                dp[b]+=dp[b-A[a]]
    return dp
def yuukoutomukou(edges):
    ret=deepcopy(edges)
    for edge in edges:
        if not edge.x==edge.y:
            ret.append(Edge(edge.y,edge.x,edge.val))
    return ret
def dijkstra(edges,V,start):
    mincost=[inf]*V
    G=[[] for a in range(V)]
    for edge in edges:
        G[edge.x].append([edge.val,edge.y])
    Q=PriorityQueue()
    Q.put([0,start])#[cost,x]
    while not Q.empty():
        nowcost,nowx=Q.get()
        if mincost[nowx]==inf:
            mincost[nowx]=nowcost
            for cost,y in G[nowx]:
                newcost=nowcost+cost
                Q.put([newcost,y])
    return mincost
def warshallfloyd(edges,V):
    mincost=[[inf for b in range(V)] for a in range(V)]
    for a in range(V):mincost[a][a]=0
    for edge in edges:
        mincost[edge.x][edge.y]=min(mincost[edge.x][edge.y],edge.val)#x→yが複数ある場合のためにmin()する
    for k in range(V):
        for s in range(V):
            for t in range(V):
                if mincost[s][k]==inf or mincost[k][t]==inf:continue
                mincost[s][t]=min(mincost[s][t],mincost[s][k]+mincost[k][t])
    return mincost
def bellemanford(edges,V,start):
    mincost=[inf]*V
    mincost[start]=0
    for _ in range(V):
        for edge in edges:
            if mincost[edge.x]==inf:continue
            mincost[edge.y]=min(mincost[edge.y],mincost[edge.x]+edge.val)
    return mincost
def getmd(x1,y1,x2,y2):
    return abs(x1-x2)+abs(y1-y2)
def geted(x1,y1,x2,y2):
    return math.sqrt((x1-x2)**2+(y1-y2)**2)
class fordfulkerson():
    def __init__(self,edges,V,s,t):
        self.V=V
        self.used=[False]*V
        self.G=[[] for a in range(V)]
        self.s=s
        self.t=t
        for edge in edges:
            self.G[edge.x].append({"x":edge.x,"y":edge.y,"cap":edge.val,"rev":len(self.G[edge.y])})
            self.G[edge.y].append({"x":edge.y,"y":edge.x,"cap":0,"rev":len(self.G[edge.x])-1})
    def dfs(self,v,t,f=inf):
        if v==t:return f
        self.used[v]=True
        for a in range(len(self.G[v])):
            x=self.G[v][a]["x"]
            y=self.G[v][a]["y"]
            cap=self.G[v][a]["cap"]
            rev=self.G[y][self.G[x][a]["rev"]]
            if self.used[y] or cap==0:continue
            f2=self.dfs(y,t,min(f,cap))
            if f2>0:
                self.G[v][a]["cap"]-=f2
                rev["cap"]+=f2
                return f2
        return 0
    def maxflow(self):
        flow=0
        while True:
            self.used=[False]*V
            zouka=self.dfs(self.s,self.t)
            if zouka==0:break
            flow+=zouka
        return flow




######################################################################################################

n=int(input())
ans=[]
now=n
while True:
    ans.append(n%26)
    n=n//26
    if n==0:
        break
ans.reverse()
for a in range(len(ans)):
    ans[a]-=1
s=""
for a in ans:
    s+=alphabet[a]
print(s)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import string
def resolve():
    N = int(input())
    lst = []
    while N!=0:
        lst.append(N%26)
        N //= 26

    st = [string.ascii_lowercase[i-1] for i in reversed(lst)]
    print("".join(st))
resolve()

Submission status: Wrong Answer

Solution code:
def main():
    N = int(input())
    ANS = []
    while N > 0:
        ANS.insert(0,chr(N%26+96))
        N = N//26
    print(''.join(ANS))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
n = int(input())

i = 1
ans = []

while n > 0:
    tmp = n % 26
    ans.append(chr(tmp+96))
    n = (n-n % 26)//26

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
N = int(input())

ans = ""

while N > 0:
  a = N%26
  N = N//26
  ans = chr(int(a+96))+ans

print(ans)

Submission status: Wrong Answer

Solution code:
#def dfs():


def main():
    n = int(input())
    tmp = n
    a = []
    while(tmp/26>0):
        #print(tmp/26, tmp%26)
        a.append(tmp%26)
        tmp//=26
    res = ""
    alp = "zabcdefghijklmnopqrstuvwxy"
    for i in a[::-1]:
        res += alp[i]
    print(res)

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

print(S[::-1])

Submission status: Wrong Answer

Solution code:
n = int(input())

alphabet = [chr(i) for i in range(97, 97+26)]
s = ''

while n != 0:
  tmp = n % 26
  s += alphabet[tmp - 1]
  n = n // 26
print(s[::-1])

Submission status: Wrong Answer

Solution code:
alphabet = "abcdefghijklmnopqrstuvwxyz"
n = int(input())
ans = []
while n > 0:
    ans.append(alphabet[n % 26 - 1])
    n //= 26

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import sys
# import re
import math
import collections
# import decimal
import bisect
import itertools
import fractions
# import functools
import copy
# import heapq
import decimal
# import statistics
import queue

# import numpy as np

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

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


# ===CODE===
def main():
    n = ni()
    diver = 26
    ans = []
    while n > 0:
        ans.append(chr(96 + n % diver))
        n //= diver

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


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python
from __future__ import division, print_function

import os
import sys
import string
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip


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

    sol = []

    while n:
        sol.append(string.ascii_lowercase[(n - 1) % 26])
        n //= 26

    print(*sol[::-1], sep='')


# region fastio

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


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

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

# endregion

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
N = int(input())

ofs = ord('a')
c = []
while N:
    x = N % 26
    c.append(chr(x-1+ofs))
    N //= 26

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

Submission status: Wrong Answer

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

    ans = []
    while N != 0:
        q, r = divmod(N, 26)
        ans.append(r)
        N = q
    ans = [chr(ord('a') + a - 1) for a in ans]
    return ''.join(reversed(ans))

print(c_one_quadrillion_and_one_dalmatians())

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from math import *

n=int(input())
ans=[]
while n>0:
	x=n%26
	ans.append(x)
	n=n//26

ans.reverse()
f=''
for i in ans:
	f=f+chr(96+i)

print(f)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
import string

cs = string.ascii_lowercase
n = int(input())

ds = []
while n:
    d = n % len(cs)
    ds.append(d - 1)

    n = n // len(cs)

ds.reverse()

#print(ds)
name = ''.join((map(lambda x: cs[x], ds)))
print(name)

Submission status: Wrong Answer

Solution code:
import sys
import math
from collections import deque

sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(input())
NMI = lambda: map(int, input().split())
NLI = lambda: list(NMI())
SI = lambda: input()


def make_grid(h, w, num): return [[int(num)] * w for _ in range(h)]


#隣接リスト 1-order
def make_adjlist_d(n, edges):
    res = [[] for _ in range(n + 1)]
    for edge in edges:
        res[edge[0]].append(edge[1])
        res[edge[1]].append(edge[0])
    return res


def make_adjlist_nond(n, edges):
    res = [[] for _ in range(n + 1)]
    for edge in edges:
        res[edge[0]].append(edge[1])
    return res


#nCr
def cmb(n, r):
    return math.factorial(n) // math.factorial(r) // math.factorial(n - r)


def main():
    N = NI()
    S = []
    while N > 0:
        S.append(N % 26)
        N = N // 26
    L = list(map(lambda x: chr(x+96), S[::-1]))
    print("".join(L))


if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
# Contest No.: ABC171
# Problem No.: C
# Solver:      JEMINI
# Date:        20200621

import sys
import heapq

def main():
    n = int(input())
    ans = ""
    alphabet = "abcdefghijklmnopqrstuvwxyz"
    while n > 0:
        ans = alphabet[(n - 1) % 26] + ans
        n //= 26
    print(ans)
    return

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
N = int(input())

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

Submission status: Wrong Answer

Solution code:
S=lambda:input()
I=lambda:int(input())
L=lambda:list(map(int,input().split()))
LS=lambda:list(map(str,input().split()))

from collections import deque

n=I()
s=deque()
abc=[chr(i) for i in range(97,123)]
while n>0:
    dg=n%26
    n//=26
    s.appendleft(abc[dg-1])
for i in s:
    print(i,end="")
print()

Submission status: Wrong Answer

Solution code:
n = int(input())
alphabet = "abcdefghijklmnopqrstuvwxyz"

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

Submission status: Wrong Answer

Solution code:
def mi():
    return map(int, input().split())

def ii():
    return int(input())

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

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
N = int(input())

ans = ''
while True:
    amari = N % 26
    N = N//26
    ans = chr(96+amari)+ans

    if N == 0:
        break
print(ans)

Submission status: Wrong Answer

Solution code:
from string import ascii_lowercase

n = int(input())
res = []
while n>0:
    res.append(ascii_lowercase[n%26-1])
    n //= 26

res.reverse()
print("".join(res))

Submission status: Wrong Answer

Solution code:
n = int(input())
ans = ''
st = 'abcdefghijklmnopqrstuvwxyz'
while n:
    idx = n%26
    ans += st[idx-1]
    n//=26

print(ans[::-1])

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

print(ans[::-1])

Submission status: Wrong Answer

Solution code:
import sys
from string import ascii_lowercase
input = sys.stdin.readline
sys.setrecursionlimit(2 * 10**6)


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


def main():
    N = int(input())
    S = ascii_lowercase
    ans = ''
    while N > 0:
        t = N % 26
        N //= 26
        ans = S[t - 1] + ans
    print(ans)
    return


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
N = int(input())
ans = []
while N:
    ans.append(N % 26)
    N //= 26
print("".join(map(lambda x: chr(x + 96), ans[::-1])))

Submission status: Wrong Answer

Solution code:
N=int(input())
alpha=[chr(ord('a') + i) for i in range(26)]
S=""
i=0
while(N>=1):
  S+=alpha[(N-1)%26]
  N=N//26
print(S[::-1])

Submission status: Wrong Answer

Solution code:
import sys

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


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

    X = 1000000000000001


    ans = []

    while N >= 26:
        ans.append(N % 26)
        N = N // 26

    ans.append(N)

    ansstr = []
    for a in ans[::-1]:
        ansstr.append(chr(ord("a") + a - 1))
    print("".join(ansstr))

    

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
N = int(input())
S = ''
while N >= 26:
	S += (chr(N%26+ord('a')-1))
	N//=26

S += chr(N+ord('a')-1)

print(S[::-1])

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 > 26:
        ans = chr(ord('a')+(N % 26)-1) + ans
        N //= 26
    ans = chr(ord('a')+(N % 26)-1) + ans
    print(ans) 
    
main()

Submission status: Wrong Answer

Solution code:
alphabets = "abcdefghijklmnopqrstuvwxyz"

N = int(input())

c = 26
w = 1
while c < N:
	c *= 26
	w += 1

n = ""
for i in range(w):
	n = alphabets[(N - 1) % 26] + n
	N //= 26

print(n)

Submission status: Wrong Answer

Solution code:
import sys, bisect, math, itertools, heapq, collections
from operator import itemgetter
# a.sort(key=itemgetter(i)) # i番目要素でsort
from functools import lru_cache
# @lru_cache(maxsize=None)
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
mod = 10**9 + 7
eps = 10**-7


def inp():
    '''
    一つの整数
    '''
    return int(input())


def inpl():
    '''
    一行に複数の整数
    '''
    return list(map(int, input().split()))


def str_inp():
    '''
    文字列をリストとして読み込む
    '''
    return list(input()[:-1])


n = inp()
ans = ""
while n:
    tmp = (n - 1) % 26
    n //= 26

    ans = chr(97 + tmp) + ans
print(ans)

Submission status: Wrong Answer

Solution code:
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
        ans = alphas[r - 1] + ans
        N = N // 26
    
    print(ans)


solve()

Submission status: Wrong Answer

Solution code:
from collections import Counter
import sys

sys.setrecursionlimit(10 ** 6)

mod = 1000000007
inf = int(1e18)

dx = [0, 1, 0, -1]
dy = [1, 0, -1, 0]


def inverse(a):
    return pow(a, mod - 2, mod)


def usearch(x, a):
    lft = 0
    rgt = len(a) + 1
    while rgt - lft > 1:
        mid = (rgt + lft) // 2
        if a[mid] <= x:
            lft = mid
        else:
            rgt = mid
    return lft



def main():
    n = int(input())
    a = []
    while n > 0:
        a.append(n % 26)
        n //= 26

    print("".join(chr(ord('a') - 1 + i) for i in a[::-1]))

main()

Submission status: Wrong Answer

Solution code:
import sys


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


def main():
    n = _i()
    r = ""
    while n > 0:
        m = n % 26
        r = chr(96+m) + r
        n -= m
        n //= 26

    return r


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

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
def base(n):
    k = 26
    from string import ascii_lowercase as c
    charall = "z" + c[:-1]
    def char(a):
        return charall[a]
    b = ""
    while n:
        b += char(n % k)
        if k < 0:
            n = 0--n // k
        else:
            n = n // k
    return b[::-1]

print(base(int(input())))

Submission status: Wrong Answer

Solution code:
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 //= 26
    return "".join(name)[::-1]


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

Submission status: Wrong Answer

Solution code:
n = int(input())

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

Submission status: Wrong Answer

Solution code:
n = int(input())

ret = []

left = n

while left > 0:
    tmp = left % 26
    ret.append(tmp)
    left = left // 26

ret.reverse()

ret2 = []

for item in ret:
    ret2.append(chr(item + 96))

print("".join(ret2))

Submission status: Wrong Answer

Solution code:
n = int(input())
num = 1
alpha = "abcdefghijklmnopqrstuvwxyz"
ans = ""
while 1 <= n:
    ans += alpha[n % 26 - 1]
    if n == 26:
        break
    n //= 26
print(ans[::-1])

Submission status: Wrong Answer

Solution code:
arp = list("zabcdefghijklmnopqrstuvwxy")
ans = []
N = int(input())
while N != 0:
    K = N % 26
    ans.append(arp[K])
    N -= K
    N = N // 26
ans.reverse()
print("".join(ans))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
n=int(input())
t="abcdefghijklmnopqrstuvwxyz"
def Base_10_to_n(X, n):
  X_dumy = X
  ans = []
  while X_dumy>0:
    ans.append(X_dumy%n)
    X_dumy = int(X_dumy/n)
  return ans
ans=""
for i in Base_10_to_n(n,26):
  ans=t[i-1]+ans
print(ans)

Submission status: Wrong Answer

Solution code:
N = int(input())
k = 1
while 26**k <= N:
    N -= 26**k
    k += 1

def itoc(i):
    return chr(ord('a') + i)

N -= 1
ans = ''
for _ in range(k):
    N,i = divmod(N,26)
    ans += itoc(i)
print(ans[::-1])

Submission status: Wrong Answer

Solution code:
N = int(input())
ans = ''
for i in range(100):
    ans = chr(ord('a') + (N-1) % 26) + ans
    N //= 26
    if N == 0:
        break
print(ans)

Submission status: Wrong Answer

Solution code:
N = int(input())

ans = ""
while N > 0:
  surplus = N % 26
  ans = chr(surplus + 96) + ans
  N //= 26
print(ans)

Submission status: Wrong Answer

Solution code:
#!usr/bin/env pypy3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect


def LI(): return [int(x) for x in sys.stdin.readline().split()]


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


def LS(): return [list(x) for x in sys.stdin.readline().split()]


def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res


def IR(n):
    return [I() for i in range(n)]


def LIR(n):
    return [LI() for i in range(n)]


def SR(n):
    return [S() for i in range(n)]


def LSR(n):
    return [LS() for i in range(n)]


sys.setrecursionlimit(1000000)


def main():
    tmp = ""
    N = I()
    while N != 0:
        amari = N % 26
        N //= 26
        tmp = chr(ord("a") + amari - 1) + tmp
    print(tmp)


main()

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:
        if n == 0:
            continue
        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())
alphabet = 'abcdefghijklmnopqrstuvwxyz'
answer = ""
while n > 0:
    tmp = n % 26
    answer+=alphabet[tmp-1]
    n=n//26

print(answer[::-1])

Submission status: Wrong Answer

Solution code:
N=int(input())

nlist=[]
while N:
  nlist.append(N%26)
  N//=26
  
nlist.reverse()
#print(nlist)

answer_list=[]
for n in nlist:
  answer_list.append(chr(96+n))
  
print("".join(answer_list))

Submission status: Wrong Answer

Solution code:
n = int(input())
nmax = 1000000000000001
alp = list("abcdefghijklmnopqrstuvwxyz")
ans = []
while n > 0:
    r = n%26
    n = (n-r)//26
    ans.append(alp[r-1])
print(''.join(ans[::-1]))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
from string import ascii_lowercase as abc
n = int(input())
a = {i + 1: s for i, s in enumerate(abc)}
ans = ''
while n >= 1:
    n, r = divmod(n, 26)
    if r == 0:
        r = 26
    ans += a[r]
print(ans[::-1])

Submission status: Wrong Answer

Solution code:
n = int(input())

m = n
cnt = 0
u = []
while(m != 0):
    cnt += 1
    u.append(m % 26)
    m = m // 26
s = 'abcdefghijklmnopqrstuvwxyz'
u.reverse()
ans = ''

for ss in u:
    ans += s[ss-1:ss]
print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
n=int(input())
a=[]
for i in range(20):
    a.append(chr(n%26+96))
    n=n//26
    if n==0:
        break
for i in range(len(a)):
    print(a[-1-i],end='')

Submission status: Wrong Answer

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

N=int(readline())

ans = ""
anum = ord("a")
# 
def num_to_alpha(num):
  return chr(anum + num)
  
while N:
  num = N % 26
  ans += num_to_alpha(num - 1)
  N //= 26
  
print(ans[::-1])

Submission status: Wrong Answer

Solution code:
n=int(input())
num=[]
ans=""
for i in range(1000):
    num.append(n%26)
    n=n//26
    if n==0:
        break
for i in range(len(num)):
    num1=96+num[-1-i]
    ans+=chr(num1)
print(ans)

Submission status: Wrong Answer

Solution code:
alphabetlist=["",'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 ind(b,n):
    res=0
    while n>=b**res:
        res+=1
    return res-1

N=int(input())
ans=[]
while N>0:
    a=ind(26,N)
    q=N//(26**a)
    ans.append(alphabetlist[q])
    N=N%(26**a)

print("".join(ans))

Submission status: Wrong Answer

Solution code:
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
INF = float("inf")


def main():
    N = int(input())
    p = []
    a = N
    while a > 0:
        p.append(a % 26)
        a //= 26

    print("".join([chr(ord('a')+n-1) for n in reversed(p)]))

    return


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
n = int(input())
ans =""
while True:

    i = n%26
    n = n // 26
    ans = chr(ord("a")+i-1) + ans
    if n ==0:
        break
print(ans)