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 in C# (.NET Core 3.1.201) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Headers;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            string in1 = Console.ReadLine();
            Int64 index = Int64.Parse(in1);
            string str = "";

            int maxDigit = GetCurDigit(index);

            double[] maxPow = GetMaxDigitArray();

            for (int i = maxDigit; i >= 0; --i)
            {

                double pow = 0.0;

                pow = Math.Pow(26.0, i);

                // 26のi乗の商を計算
                double quotient = Math.Floor(index / pow);

                if (i != 0)
                {
                    if (-0.000001 <= Math.Floor(index % pow) && Math.Floor(index % pow) <= 0.000001)
                    {
                        quotient -= 1;
                    }
                    else if (quotient > 26)
                    {
                        quotient = 26;
                    }
                }


                char curDigit = (char)((int)quotient + 0x40);

                str = str + curDigit.ToString();

                // 上の桁を計算したので、下の桁へ移行
                index = index - (int)(quotient * pow);
            }

            Console.WriteLine("{0}", str);
        }
        /// <summary>
        /// 現在の桁数
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public static int GetCurDigit(Int64 index)
        {
            int maxDigit = 20;

            double[] maxPow = GetMaxDigitArray();
            double[] minPow = new double[maxDigit];

            // アルファベット26進の桁の最小値 計算 
            // ( 例. 3桁なら 26*26 + 26 + 1 = AAA )

            minPow[0] = 1;
            for (int i = 1; i < minPow.Length; ++i)
            {
                minPow[i] = maxPow[i - 1] + 1;
            }


            int curDigit = 0;

            // indexが26の何乗か分の桁を持っているかを計算する
            for (int i = 0; i < maxPow.Length - 1; ++i)
            {
                if (minPow[i] <= index && index <= maxPow[i])
                {
                    curDigit = i;
                    break;
                }
            }

            return curDigit;
        }

        /// <summary>
        /// 最大桁の配列
        /// </summary>
        /// <returns></returns>
        private static double[] GetMaxDigitArray()
        {
            int maxDigit = 20;

            double[] maxPow = new double[maxDigit];

            // アルファベット26進の桁の最大値 計算 ( 例. 3桁なら 26*26*26 + 26*26 + 26 = ZZZ) 
            for (int i = 0; i < maxPow.Length; ++i)
            {
                maxPow[i] = Math.Pow(26.0, i + 1);

                for (int j = i; j > 0; --j)
                {
                    maxPow[i] += Math.Pow(26.0, j);
                }
            }

            return maxPow;
        }

    }
}