[Question]
  [
I don't like numbers, but I do like the Fibonacci sequence. I'm sure we could work something out. 
Please read one integer *n* from STDIN and output the *n*th Fibonacci number in base 26 (`abcdefghijklmnopqrstuvwxyz` instead of `0123456789`) to STDOUT.
The first Fibonacci number is 0. The second one is 1. The *n*th fibonacci number is the sum of the *n*-2nd and *n*-1st Fibonacci numbers.
First 32 fib-abc numbers:
```
fib(0) = a
fib(1) = b
fib(2) = b
fib(3) = c
fib(4) = d
fib(5) = f
fib(6) = i
fib(7) = n
fib(8) = v
fib(9) = bi
fib(10) = cd
fib(11) = dl
fib(12) = fo
fib(13) = iz
fib(14) = on
fib(15) = xm
fib(16) = blz
fib(17) = cjl
fib(18) = dvk
fib(19) = gev
fib(20) = kaf
fib(21) = qfa
fib(22) = baff
fib(23) = bqkf
fib(24) = cqpk
fib(25) = egzp
fib(26) = gxoz
fib(27) = leoo
fib(28) = scdn
fib(29) = bdgsb
fib(30) = bvivo
fib(31) = cypnp
```
This is code golf, so shortest code in bytes wins!
  
[Answer]
# CJam, 18 bytes
```
UXri{_@+}*;26b'af+
```
Try it online in the [CJam interpreter](http://cjam.aditsu.net/#code=UXri%7B_%40%2B%7D*%3B26b'af%2B&input=31).
### How it works
```
UX    e# Push 0 and 1.
ri{   e# Read an integer and execute the loop that many times.
  _   e#   Push a copy the topmost integer.
  @   e#   Rotate the bottom-most integer on top of the stack.
  +   e#   Pop the two topmost integers and push their sum.
}*    e#
;     e# Discard the topmost integer from the stack.
26b   e# Convert the remaining integer to base 26.
'af+  e# Add the character 'a' to each base-26 digit.
```
[Answer]
# [TeaScript](https://esolangs.org/wiki/TeaScript), 34 bytes  ~~37~~   ~~51~~   ~~54~~
TeaScript is JavaScript for golfing. It also brings ES2015 features to the average browser.
```
F(x)b(26)l(#C(lc()+(l<'a'?49:10)))
```
[Try it online](http://vihanserver.tk/p/TeaScript/?code=F(x).b(26).l(%23C(l.c()%2B(l%3C'a'%3F49%3A10)))&input=27&v=1)
### Explanation
```
          // x is the input
F(x)      // Fibonacci from input
.b(26)    // To Base-26 string but with 0-9, a-p
          // instead of a-z, to fix this...
.l(#      // Loops through each char
   C(          // Charcode from...
       l.c()+  // Charcode from char
       (l<'a'? // If number
           49  // Add 49 to char code
          :10  // Else add 10
       )
   )
)
```
\*This answer is non-competing
[Answer]
# Mathematica, ~~67~~ 61 bytes
```
Print[""<>Alphabet[][[Fibonacci@Input[]~IntegerDigits~26+1]]]
```
Calculates `f(1000000)` in about 51 milliseconds.
[Answer]
# [Simplex v.0.6](http://conorobrien-foxx.github.io/Simplex/#commands), 35 bytes
Sometimes I sigh and think, "Is this even worth submitting? It doesn't win, so why bother?" In response, I think, "Heck. It was fun. Besides, this is really fancied-up brainf\*\*\* anyhow. Not too shabby."
```
5_*Ij1~SRpRi@T[Uj&ERp]pSR5_Vj26@pWo
5_                                  ~~ sqrt(5)
  *                                 ~~ copy to next byte, move right
   I                                ~~ increment [sqrt(5),sqrt(5)+1]
    j1                              ~~ insert a new cell and set it to one 
                                    ~~ [sqrt(5),1,sqrt(5)+1]
      ~                             ~~ switch the previous with the current byte
                                    ~~ [1,sqrt(5),sqrt(5)+1]
       S                            ~~ perform subtraction [1-sqrt(5),0,sqrt(5)+1]
        Rp                          ~~ remove next cell [1-sqrt(5),sqrt(5)+1]
          Ri@                       ~~ take numeric input (n) into register
             T[      ]              ~~ applies the following to every cell
               U                    ~~ halves the current cell
                j&                  ~~ dumps and restores the value to the register
                  ERp               ~~ raises cell to the nth power, remove cell made
                      p             ~~ remove last cell
                       S            ~~ subtract the two values
                        R5_         ~~ goes right and sets sqrt(5)
                           V        ~~ divides the prev. two cells
                            j       ~~ inserts new cell
                             26@    ~~ puts 26 into the register
                                p   ~~ removes cell
                                 Wo ~~ converts the current to base 26 and outputs as number
```
[Answer]
# Pyth, 17 bytes
```
s@LGjhu,eGsGQU2lG
```
[Try it](https://pyth.herokuapp.com/?code=s%40LGjhu%2CeGsGQU2lG&input=31&debug=0) online.
[Answer]
## [Minkolang 0.9](https://github.com/elendiastarman/Minkolang), 40 bytes
```
10n[0c+r]$x'26'r(d0c%1G0c:d$)xrx("a"+O).
```
[Try it here.](http://play.starmaninnovations.com/minkolang/?code=10n%5B0c%2Br%5D%24x%2726%27r%28d0c%251G0c%3Ad%24%29xrx%28%22a%22%2BO%29.&input=20)
### Explanation
```
10n[0c+r]                                   Calculates f(n) where n is taken from input
         $x'26'r                            Dumps the addend I don't need and pushes a 26
                (d0c%1G0c:d$)               Base-encodes f(n) in base 26
                             xrx            Dumps the 0, reverses, dumps the 26
                                ("a"+O).    Outputs the letters
```
[Answer]
# Python 2.7, 82 bytes
```
a=0
b=1
s=''
exec"a,b=b,a+b;"*input()
while a:s=chr(a%26+97)+s;a/=26
print s or'a'
```
[Answer]
# [Whispers v3](https://github.com/cairdcoinheringaahing/Whispers), 111 bytes
```
> Input
> fₙ
>> ≺1
>> 2ᶠ1
>> 4ⁿ3
> 26
>> 5⊥6
> 97
>> 8+R
>> Each 9 7
>> 'R
>> Each 11 10
>> Output 12
```
[Try it on repl.it!](https://repl.it/@razetime/Whispers-online-runner#fibabc.wisp)
Needs to be run as `python3 whispers\ v3.py fibabc.wisp < input.txt 2> /dev/null` with input given on the first line of `input.txt`.
I think the first and last lines can be removed [as per the consensus here](https://codegolf.meta.stackexchange.com/questions/20737/can-whispers-programs-ignore-a-final-output-line), but I'm not sure.
8 bytes shorter than hardcoding the alphabet: [Try it on repl.it!](https://repl.it/@razetime/Whispers-online-runner#fibabc2.wisp)
[Answer]
# Haskell, 114 chars.
It is unexpectedly long. Any help welcome. Previously found a bug for fib(0)
```
f=scanl(+)0$1:f
k 0=[]
k x=k(x`div`26)++[toEnum$97+x`mod`26]
l 0=0
l x=k x
main=interact$l.(f!!).read.head.lines
```
`f` is infinite list of fibonacci. `toEnum` is same with `chr`, except that former doesn't need to import Data.Char.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes
```
ÆḞṃØaṙ1¤
```
[Try it online!](https://tio.run/##ASYA2f9qZWxsef//w4bhuJ7huYPDmGHhuZkxwqT/4bi2w4figqxZ//8zMg "Jelly – Try It Online")
## How it works
```
ÆḞṃØaṙ1¤ - Main link. Takes an integer N on the left
ÆḞ       - Take the Nth Fibonacci number
       ¤ - Group the previous links into a nilad:
   Øa    -   "abc...xyz"
     ṙ1  -   Rotate once; "bcd...yza"
  ṃ      - Base decompress; Convert to base 26 then index into the string
```
[Answer]
# [JavaScript (V8)](https://v8.dev/), 94 bytes
```
x=>(f=n=>n>1?f(n-1)+f(n-2):1)(x)[S="toString"](26).replace(/./g,l=>(parseInt(l,26)+10)[S](36))
```
[Try it online!](https://tio.run/##XdA/C8IwEIfh3Y/hdIfV9i5a/0Dq7OwoHWppS6XEUIP47Wuc5NcpvBzHPeRRvatXPfY@rN@Hqe3vdvrYglrrbOEKObfk1sKr36N8EqYP3652GZ7XMPauW5akOW/Gxg9V3VC6SbtkiPu@Gl/NxQUakjhfSRa3SjI58@TjXqB4iTLmxb8ESqEM1BZqB5VD7aEOUEe8PsOgRpAj6BEECYoESYImQZSgSlGlsz9ClaJKUaWoUlQpqhRViiqDKhNV0xc "JavaScript (V8) – Try It Online")
Uses recursion to find factorial, and some `toString`, `replace`, and `parseInt` magic to convert to letters.
[Answer]
# [Zsh](https://www.zsh.org/), 68 bytes
```
<<<A;{for ((a=1;b+=a;a+=b))<<<$[[##26]a]<<<$[[##26]b]}|tr 0-9A-P A-Z
```
[Try it online!](https://tio.run/##qyrO@K/x38bGxtG6Oi2/SEFDI9HW0DpJ2zbROlHbNklTEyilEh2trGxkFpsYi8RJiq2tKSlSMNC1dNQNUHDUjfqvWZORmpiioKtiqFack5paoKBn9P@/sQEA "Zsh – Try It Online")
Pure fibonacci code stolen from [here](https://codegolf.stackexchange.com/a/190972).
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 6 bytes
If a list of characters is fine as output, the `J` can be removed.
```
ÅfAÅвJ
```
[Try it online!](https://tio.run/##yy9OTMpM/W9seGySn1JaZpLG4f2aCrYKSvZ@/w@3pjkebr2wyeu/zn8A "05AB1E – Try It Online")
```
Åf      # get the nth Fibonacci number
  A     # push the lowercase alphabet
   Åв   # convert the Fibonacci number to this custom base
     J  # join the list of digits into a string
```
[Answer]
# Ruby, 67 bytes
```
a,b=0,1
gets.to_i.times{a,b=b,a+b}
puts a.to_s(26).tr"0-9a-p","a-z"
```
[Answer]
# Matlab, 133 bytes
```
n=input('');if n<2,y=n;else
f=0;g=1;for k=2:n
h=f+g;f=g;g=h;end
y=fix(mod(g./26.^(fix(log(g)/log(26)):-1:0),26));end
disp(char(y+97))
```
[Answer]
# Ruby, 125 bytes
Not gonna win any time soon, but it was fun & my first code golf :')
```
def f(n);n<3?(n>0?1:0):f(n-1)+f(n-2);end
def a(s);s.bytes.map{|n|n<58?n+49:n+10}.pack("C*");end
puts a(f(gets.to_i).to_s(26))
```
First line is a function to compute fibonacci, second converts from Ruby's built-in base 26 encoding (0-9 then a-p) into a-z encoding, third gets a line from STDIN and runs it through both.
]