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):
N = int(input()) - 1
K = 26
j = 0
for i in range(1, 100):
    if N >= K ** i:
        N -= K ** i
        j = i
S = ""
for i in range(j + 1)[::-1]:
    k = N // (K ** i)
    N %= K ** i
    S += chr(97 + k)
print(S)

Solution (Python):
from collections import deque,defaultdict as dd 
from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
from itertools import permutations
from datetime import datetime
from math import ceil,sqrt,log,gcd
def ii():return int(input())
def si():return input()
def mi():return map(int,input().split())
def li():return list(mi())
abc='abcdefghijklmnopqrstuvwxyz'
abd={'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod=1000000007

inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]

def bo(i):
    return ord(i)-ord('a')



def convertToTitle(num):
    capitals = [chr(x) for x in range(ord('a'), ord('z')+1)]
    result = []
    while num > 0:
        result.append(capitals[(num-1)%26])
        num = (num-1) // 26
    result.reverse()
    return ''.join(result)

n=ii()
print(convertToTitle(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)

N = int(input())

print(num2alpha(N).lower())

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

ans = []
while n:
    n -= 1
    q, r = divmod(n, 26)
    c = chr(ord("a") + r)
    ans.append(c)
    n = q

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

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

Solution (Python):
n = int(input())
arr = []
while n != 0:
  arr.append(chr(ord("a") + (n-1) % 26))
  n = (n-1)//26
arr.reverse()
print("".join(arr))

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):
mod = 1000000000000001
def num2alpha(num):
    if num<=26:
        return chr(64+num).lower()
    elif num%26==0:
        return num2alpha(num//26-1)+chr(90).lower()
    else:
        return num2alpha(num//26)+chr(64+num%26).lower()

print(num2alpha(int(input())))

Solution (Python):
n = int(input())
alph = "zabcdefghijklmnopqrstuvwxy"


ans = ""
while n >= 1:
    div, mod = divmod(n, 26)
    ans += alph[mod]
    n = div
    if mod == 0:
        n -= 1
print(ans[::-1])

Solution (Python):
import sys
input=lambda: sys.stdin.readline().rstrip()
n=int(input())
A=[]
while n>0:
  n-=1
  A.append(n%26)
  n//=26
ans=""
for a in A:
  ans+=chr(97+a)
print(ans[::-1])

Solution (Python):
def colnum_string(n):
    string = ""
    while n > 0:
        n, remainder = divmod(n - 1, 26)
        string = chr(97 + remainder) + string
    return string

n = int(input())
print(colnum_string(n))

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

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

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

s = ''
for _ in xrange(l):
    s += chr(ord('a') + n % 26)
    n /= 26

print s[::-1]

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(96+num)
    elif num%26==0:
        return num2alpha(num//26-1)+chr(122)
    else:
        return num2alpha(num//26)+chr(96+num%26)

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

Solution (Python):
n = int(input())
ans = ''
i = 1
while(n):
    k = (n - 1) % 26
    ans += chr(ord('a') + k)
    n -= k
    n //= 26
ans = ans[::-1]
print(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(num2alpha(n).lower())

Solution (Python):



import string


def generate_sequence(n):
    n -= 1
    def gen(result, x):
        if x < 0:
            return result
        else:
            d, m = divmod(x, 26)
            char = string.ascii_lowercase[m]
            return gen(char + result, d - 1)
    return gen("", n)


main = lambda: print(generate_sequence(int(input())))


if __name__ == '__main__':
    main()

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

l = 1
while N>=26**l:
  N -= 26**l
  l += 1

ans = ""
for i in range(l):
  ans += chr(ord("a")+N//26**(l-i-1)%26)
print(ans)

Solution (Python):
import sys

sys.setrecursionlimit(500005)
stdin = sys.stdin

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

n = ni() - 1
l = 1

nus = [1]
for i in range(20):
    nus.append(nus[-1] * 26)

while True:
    if n < nus[l]:
        s = ""
        for i in range(l):
            s += chr(n%26+97)
            n //= 26
        print(s[::-1])
        break
    n -= nus[l]
    l += 1

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

Solution (Python):
N=int(input())
S=""
while N:
    N-=1
    S+=chr(ord("a")+N%26)
    N//=26
print(S[::-1])

Solution (Python):
N = int(input())
abc = list("abcdefghijklmnopqrstuvwxyz")

ans = ""

while N:
  N -= 1
  ans += abc[N % 26]
  N //= 26

print(ans[::-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):
def main():
    from string import ascii_lowercase

    N = int(input())

    ans = ''
    while N > 0:
        N -= 1
        N, r = divmod(N, 26)
        ans = ascii_lowercase[r] + ans

    print(ans)


if __name__ == '__main__':
    main()

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

s = "abcdefghijklmnopqrstuvwxyz"
ans = ''
while n > 0:
    n -= 1
    ans = s[n % 26] + ans
    n //= 26
print(ans)

Solution (Python):
n=int(input())
ans=""
List=["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>0:
    name=(n-1)%26
    ans=List[name]+ans
    n=(n-1-name)//26
    
print(ans)

Solution (Python):
N = int(input())
alphabets = [chr(i) for i in range(ord('a'), ord('a') + 26)]

ans = ''
while N > 0:
    N -= 1
    ans += alphabets[N % 26]
    N = N // 26


print(ans[::-1])

Solution (Python):

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)
mod = 1000000007

def solve():
    n = I()
    n -= 1
    ans = []
    while n >= 0:
        ans.append(chr(ord("a")+n%26))
        n //= 26
        n -= 1
    print(*ans[::-1],sep="")
    return


if __name__ == "__main__":
    solve()

Solution (Python):
n = int(input())
s = ""
abc = "abcdefghijklmnopqrstuvwxyz"
while n:
    s = abc[(n - 1) % 26] + s
    n -= 1
    n //= 26

print(s)

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):
FAST_IO = 0
if FAST_IO:
    import io, sys, atexit
    rr = iter(sys.stdin.read().splitlines()).next
    sys.stdout = _OUTPUT_BUFFER = io.BytesIO()
    @atexit.register
    def write():
        sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
else:
    rr = raw_input
rri = lambda: int(rr())
rrm = lambda: map(int, rr().split())
rrmm = lambda n: [rrm() for _ in xrange(n)]



from collections import defaultdict as ddic

def solve(N):
    ans = []
    while True:
        N -= 1
        r = (N) % 26
        N //= 26
        ans.append(chr(r + ord('a')))

        if N == 0: break
    return "".join(ans[::-1])
print solve(rri())