Letters associated with prime numbers

Question

If we assign each letter a respective integer, starting from 1, then a is 1, b is 2, c is 3, and so on. After z, the letters loop back around, but with a in front (aa, ab, ac). It then goes to ba, bb, bc... After this is completed, as you may have figured, another letter is added (aaa, aab, aac). "Prime letters" would be letters that are associated with a prime number. b would be the first prime letter, followed by c, e, g, et cetera.

The Challenge

Given an input n, find the nth "prime letter."

Examples

Input:

1

Output:

b

Input:

4

Output:

g

Input:

123

Output:

za

Scoring Criteria

This is code golf, so the shortest answer in bytes wins!

Answer 1

Python 3,262 236 209 196 179 114 93 92 97 bytes

def f(n):
 m=k=1;s=''
 while n:m*=k*k;k+=1;n-=m%k
 while k:s=chr(~-k%26+97)+s;k=~-k//26
 return s

Try it online!

Fixed a bug mentioned by @benrg about getting a wrong output for the input 123.

Thanks to:
- @AdmBorkBork for help me getting started and save a few bytes
- @Sriotchilism O'Zaic for saving me 6 bytes
- @mypetlion for saving me 65 bytes and bringing me under 150 bytes :)
- @dingledooper for saving me 21 bytes and bringing me under 100 bytes :D
- @Jitse for saving 1 byte

---

98 bytes

f=lambda n,i=1,p=1:n and-~f(n-p%i,i+1,p*i*i)
g=lambda n,s='':n and g(~-n//26,chr(~-n%26+97)+s)or s

Try it online!

Answer 2

Jelly, 8 bytes

ÆNḃ26ịØa

A monadic Link which accepts a non-negative integer that yields a list of characters.

Try it online!

How?

ÆNḃ26ịØa - Link: integer, n
ÆN       - nth prime
   26    - literal 26
  ḃ      - bijective base
      Øa - literal list of characters = ['a', 'b', ..., 'z']
     ị   - index into

Answer 3

JavaScript (Node.js), 83 bytes

f=(n,k=0)=>n?f(n-(g=d=>~k%d--?g(d):!d)(++k),k):k<0?'':f(n,k/26-1)+Buffer([k%26+65])

Try it online!

Commented

f = (                // f is a recursive function taking:
  n,                 //   n = input
  k = 0              //   k = counter
) =>                 //
  n ?                // if n is not equal to 0:
                     //   == 1st pass: find the requested prime ==
    f(               //   do a recursive call:
      n - (          //     pass the updated value of n
        g = d =>     //     g is a recursive function which takes d = k
                     //     and tests the primality of k + 1:
          ~k % d-- ? //       if d is not a divisor of (k + 1):
                     //       (decrement d afterwards)
            g(d)     //         do recursive calls until it is
          :          //       else:
            !d       //         return true if d = 0
      )(++k),        //     increment k and invoke g
                     //     so we decrement n if k is prime
      k              //     pass k
    )                //   end of recursive call
  :                  // else:
                     //   == 2nd pass: convert the prime to a string ==
    k < 0 ?          //   if k is negative:
      ''             //     return an empty string and stop
    :                //   else:
      f(             //     do a recursive call:
        n,           //       pass n (which is now 0)
        k / 26 - 1   //       pass k / 26 - 1
      ) +            //     end of recursive call
      Buffer([       //     append the letter corresponding to
        k % 26 + 65  //     k mod 26
      ])             //

Answer 4

Wolfram Language (Mathematica), 53 bytes

Flatten[Tuples[Alphabet[],#]&/@Range@4,1][[Prime@#]]&

Try it online!

Answer 5

Ruby -rprime, 48 47 46 43 bytes

-5 bytes from GB.

->n{(?A..?Z*n).take(Prime.take(n)[-1])[-1]}

Try it online!

Answer 6

PHP, 69 bytes

for($n=1,$a=a;$argn||!print$a;$m||--$argn,$a++)for($m=$n++;$n%$m--;);

Try it online!

Answer 7

Java (JDK), 170 163 158 157 155 bytes

String p(int n){int c=0,i,v=1;String s="";while(c<n){v++;for(i=2;i<=v;i++)if(v%i<1)break;if(i==v)c++;}while(v>0){s=(char)(~-v%26+97)+s;v=~-v/26;}return s;}

Try it online!

Thanks to @Delta for saving me 14 bytes in total

Answer 8

05AB1E, 18 bytes

<Ø[₂‰˜0KZ27‹#}<Asè

Isn't there a convenient builtin to do this shorter?.. I have the feeling I should be able to use one of the base-conversion builtins here, but it isn't really working out.. Can without a doubt be golfed substantially, though..

Try it online or verify some more test cases.

Explanation:

<              # Decrease the (implicit) input-integer by 1 to make it 0-based
 Ø             # Get the 0-based n'th prime
  [            # Start an infinite loop:
   ₂‰          #  Take the divmod 26
     ˜         #  Flatten the resulting list
      0K       #  And remove any 0s
        Z      #  Get the maximum of the list (without popping)
         27‹   #  If it's smaller than 27:
            #  #   Stop the infinite loop
  }<           # After the loop: decrease all values by 1 to make it 0-based
    A          # Push the lowercase alphabet
     sè        # And index the list of integers into it
               # (after which the resulting character-list is output implicitly as result)

Answer 9

Java, 169 Bytes

isProbablePrime is only valid for 32 bit integers, but it is correct for every 32 bit integer, so this is a valid solution.

(int n)->{int x=-1;for(int i=0;i<n;){x++;if(BigInteger.valueOf(x).isProbablePrime(15))i++;}String r="";while(x>0){x--;int m=x%26;r=(char)(m+97)+r;x=(x-m)/26;}return r;};

Answer 10

Icon, 135 bytes

procedure f(n)
k:=seq()&s:=0&0=k%(i:=2to k)&s+:=1&i=k&s=1&p:=k-1&n-:=1&n=0
t:="";until t[1:1]:=char(97+p%26)&p:=p/26-1&p<0;return t
end

Try it online!

Answer 11

Pyth, 27 bytes

VQ.VhZIP_b=ZbB;p*\a/Z26@GtZ

Explaination:

                            # Implicit Q = eval(input())
                            # Implicit Z = 0
VQ                          # for N in range(Q)
  .VhZ                      #     for b in infinite_range(Z+1)
      IP_b                  #         if is_prime(b)
          =Zb               #             Z = b
             B;             #             break
             p*\a/Z26       # print("a"*Z//26, end="")
                     @GtZ   # 
                            # Implicit print(G[Z-1])