Il tuo compito è tradurre un numero di 103 caratteri in una parola inglese, usando il metodo descritto di seguito.

Come?

1. Genera l'elenco dei fattori primi (con ripetizione) del numero di input.
2. Ordina l'elenco:
   • Se 2 non è uno dei fattori primi, ordina l'elenco in ordine crescente.
   • Se 2 è uno dei fattori primi, rimuoverlo dall'elenco e ordinare i restanti fattori in ordine decrescente.

3. Traduci ogni fattore in una lettera, usando la seguente tabella:

    3 = S   13 = L   29 = X   43 = O   61 = Z   79 = H  101 = K  
    5 = P   17 = Q   31 = N   47 = R   67 = T   83 = V  103 = Y  
    7 = M   19 = U   37 = C   53 = A   71 = E   89 = D  
   11 = F   23 = I   41 = W   59 = G   73 = J   97 = B  
   

_{Nota : questa tabella è stata costruita empiricamente per massimizzare il numero di parole possibili. Per i curiosi, ecco un elenco di 2.187 parole che possono essere codificate in questo modo (può includere un linguaggio volgare). Non è sicuramente garantito per essere ottimale, ma è abbastanza buono per questa sfida.}

Esempi

Esempio 1: 579085261 (ordine crescente)

1. I fattori primi sono [37, 47, 53, 61, 103] .
2. 2 non è un fattore primo, quindi manteniamo l'elenco ordinato in ordine crescente.
3. 37 = C, 47 = R, ecc. L'output è "CRAZY".

Esempio 2: 725582 (ordine decrescente)

1. I fattori primi sono [2, 11, 13, 43, 59] .
2. 2 è un fattore primo, quindi lo rimuoviamo e ordiniamo l'elenco in ordine decrescente, che dà:
   [59, 43, 13, 11] .
3. 59 = G, 43 = O, ecc. L'output è "GOLF".

Esempio 3: 10757494 (con un fattore ripetuto)

1. I fattori primi sono [2, 11, 71, 71, 97] .
2. 2 è un fattore primo, quindi lo rimuoviamo e ordiniamo l'elenco in ordine decrescente, che dà:
   [97, 71, 71, 11] .
3. 97 = B, 71 = E, 11 = F. L'uscita è "BEEF".

Chiarimenti e regole

• Il numero di input è garantito per 103 liscio e divisibile per 2 al massimo una volta.
• Per definizione, un numero progressivo è un numero intero positivo .
• L'input e l'output possono essere gestiti in qualsiasi formato ragionevole. L'output può essere in minuscolo o maiuscolo. Lo spazio bianco finale è accettabile. Lo spazio bianco principale non lo è.
• Se il tuo programma / funzione non può supportare input di grandi dimensioni, specificalo nella tua risposta.
• Questo è il golf del codice, quindi vince la risposta più breve in byte.

Casi test

34874          --> ARM
483254         --> BAR
353722         --> EAR
494302         --> EGG
39061          --> FAT
6479           --> FUN
60421          --> ICE
54166          --> JAM
48911474       --> BETA
2510942        --> BOOM
2303854        --> DOOM
844261         --> FIRE
1606801        --> MAZE
1110085        --> PAGE
5212974        --> BALLS
67892046       --> BEANS
885396199      --> CREEK
67401037       --> FUNKY
27762173       --> QUICK
1238440506     --> ARROWS
33045832681    --> CRAGGY
1362714005     --> PIRATE
137302698      --> TROLLS
358310128062   --> BEGGARS
40255151586    --> DETAILS
164633248153   --> FIXATED
621172442227   --> UNRATED
2467812606     --> VACUUMS
86385078330    --> GROWNUPS
26607531423091 --> UNWORTHY

Gelatina , 29 27 byte

ÆEµØA“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?xḊṚḢ}¡

Grazie a @JonathanAllan per il golf off 1 byte!

Provalo online!

sfondo

“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’

è un letterale numerico. I caratteri tra virgolette vengono sostituiti con i loro indici basati su 1 nella tabella codici Jelly e l'array risultante viene interpretato come un numero base-250. Questo produce l'intero c: = 288824892868083015619552399 .

Come funziona

ÆEµØA“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?xḊṚḢ}¡  Main link. Argument: n

ÆE                           Yield the exponents of n's prime factorization, with.
                             zeroes. This yields an array A.
  µ                          Begin a new monadic chain with argument A.
   ØA                        Set the return value to “ABC...XYZ”.
     “¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?        Select the c-th permutation of the alphabet, yielding
                             s := “SPMFLQUIXNCWORAGZTEJHVDBKY”.
                      Ḋ      Dequeue; yield A without its first element, stripping
                             the exponent of 2.
                     x       Repeat the k-th letter of s r times, where r is the
                             exponent of the k-th odd prime number.
                          ¡  Combine the two links to the left into a quicklink:
                        Ḣ}     - Apply head to the right argument (A), yielding the
                                 exponent of 2. Since n is at most divisible by the
                                 first power of 2, this yields 1 for even numbers
                                 and 0 for odd ones. Call the link to the left that
                                 many times on the previous return value.
                       Ṛ       - Reverse the string to the left.

Gelatina , 36 byte

“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?ØA1;;⁶
×107ÆE¢×UḢ¡t⁶

Provalo online!

Spiegazione

Costante di supporto1£ (produce “SPMFLQUIXNCWORAGZTEJHVDBKY ”con 1 anteposto)

“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?ØA1;;⁶
“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’          288824892868083015619552399 (compressed representation)
              œ?ØA      th permutation of the alphabet
                  1;    prepend 1
                    ;⁶  append a space

Programma principale

×107ÆE¢×UḢ¡t⁶
×107           Multiply {the input} by 107
    ÆE         Convert to a list of frequencies for each factor
      ¢×       {Vectorized} multiply by the return value of 1£
        UḢ¡    Delete the first value, reverse the list that many times
           t⁶  Delete trailing/leading space

Ho la sensazione che la mia compressione dell'elenco superi facilmente la risposta dell'altra Jelly, ma che il mio algoritmo per usarlo potrebbe essere molto più efficiente. Forse proverò a combinarli.

Jelly , 31 byte, ispirata alla risposta di @ Leakynun

“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?ØA⁷;
ÆfÆCị¢U⁸¡U

Provalo online! (leggermente modificato per correre molto più velocemente)

Non è coerente se stampa una nuova riga finale (ma PPCG normalmente consente risposte con o senza una nuova riga finale, quindi immagino che funzioni anche questo?). È molto lento (O ( n ) dove n è l'input e quei numeri non sono esattamente piccoli ...)

Spiegazione

Costante di supporto1£ (produce “¶SPMFLQUIXNCWORAGZTEJHVDBKY”, dove ¶è newline)

“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?ØA⁷;
“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’          288824892868083015619552399 (compressed representation)
              œ?ØA      th permutation of the alphabet
                  ⁷;    prepend newline

Programma principale

ÆfÆCị¢U⁸¡U
Æf          Produce list of prime factors (repeating repeated factors)
  ÆC        Map the nth prime to n
    ị¢      Index into the output of 1£
      U     Reverse
        ¡   a number of times
       ⁸    equal to the input
         U  Reverse again

05AB1E , 39 38 byte

ÒW<iR¨}26LØR•6Ê2"£´õþÕàçŸôëÂÛ*™•36BS:J

Utilizza la codifica CP-1252 . Provalo online!

Python 2, 220 217 byte

n=input()
i=1
L=[]
exec'i+=1;c=0\nwhile n%i<1:c+=1;n/=i\nif c:L+=[i]*c\n'*n
T='SPMFLQUIXNCWORAGZTEJHVDBKY'
print''.join(T[[p for p in range(3,104)if all(p%k for k in range(2,p))].index(q)]for q in[L,L[:0:-1]][L[0]<3])

Provalo online : esegue solo il più piccolo test case senza esaurire la memoria

Ungolfed:

Questa versione non viene utilizzata exec, quindi puoi effettivamente testare tutti i casi di test senza esaurire la memoria.

n=input()
i=1
L=[]
while~-n:
 i+=1;c=0
 while n%i<1:c+=1;n/=i
 if c:L+=[i]*c
if L[0]<3:L=L[:0:-1]
T='SPMFLQUIXNCWORAGZTEJHVDBKY'
print''.join(T[[p for p in range(3,104)if all(p%k for k in range(2,p))].index(q)]for q in L)

Provalo online

Rubino , 139 138 134 125 120 115 + 7 = 146 145 141 132 127 122 byte

Utilizza il -rprimeflag per +7 byte.

-1 byte da @daniero. -4 byte ricordando che posso semplicemente fare un controllo di divisibilità regolare invece di controllare la divisione primaria per l'esistenza di 2.

-9 byte dalla soluzione Python di @ mbomb007 che mi ricorda un modo più breve per recuperare la lettera corrispondente.

-5 byte perché è ora consentito lo spazio bianco finale.

-5 byte dalla scoperta Enumerable#find_index

->n{x=Prime.prime_division n;x.reverse!if n%2<1;x.map{|i,c|" SPMFLQUIXNCWORAGZTEJHVDBKY"[Prime.find_index i]*c}*''}

Provalo online! (tutti i casi di test)

Spiegazione

->n{                                   # Anonymous procedure with one argument n
    x=Prime.prime_division n;          # Get prime factorization of n, sorted
                                       # p0^e0 * p1^e1 ... -> [[p0,e0],[p1,e1],...]
    x.reverse!if n%2<1;                # Reverse if divisible by 2
    x.map{|i,c|                        # For each prime/exponent pair:
        " SPMFLQUIXNCWORAGZTEJHVDBKY"[ # Get corresponding character by obtaining:
            Prime.find_index i]        # Determine index of the current prime
                               *c      # Repeat the letter by the supplied exponent
                                 }*''} # Join all letter sequences together

Bash + utility GNU + pacchetto bsd-games, 170

Sembra piuttosto non ottimale, ma funziona:

p='printf %03d\n'
a=(`factor $1`)
x=$[a[1]<3]
$p `primes 3 104`|paste - <(fold -1<<<SPMFLQUIXNCWORAGZTEJHVDBKY)|join -o1.2 - <($p ${a[@]:x+1})|(((x))&&tac||cat)|tr -d \\n

Provalo online .

Gelatina , 33 byte

ÆfÆCUṖ$¹e@?1’ị“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?ØA¤

Provalo online!

Japt , 51 50 byte

49 byte di codice, +1 per la -Pbandiera.

%2?Uk :Uk Åw)£`yspmflquixncÙgz’jhvdbk`g#ho fj bX

Provalo online!

Questo potrebbe essere più breve se solo Japt avesse un paio di funzionalità in più ...

Spiegazione

`yspmflquixncÙgz’jhvdbk`è esattamente la stessa stringa che tutti gli altri usano compressi tanto quanto Japt può comprimerlo (3 byte in meno dell'originale!). Al momento l'unico strumento di compressione incorporato di Japt sostituisce le coppie comuni di lettere minuscole con un carattere a byte singolo.

Esaminiamo quindi il codice attuale:

%2?Uk :Uk Å  w)
%2?Uk :Uk s1 w)
%2?             // If the input mod 2 is non-zero,
   Uk           //   take the prime factors of the input (U).
      :Uk       // Otherwise, take the prime factors of the input,
          s1 w  //   slice off the first one (2), and reverse.

Quindi £viene utilizzato per sostituire ogni elemento Xnel risultato in questo modo:

"string"g#h o fj bX
"string"g104o fj bX

         104o         // Create the range [0...104).
              fj      // Filter to only items Z where Z.j() is truthy (Z is prime).
                      // This results in the list of prime numbers from 2 to 103.
                 bX   // Take the index of X in this list.
"string"g             // Get the char in the compressed string at that index.
                      // For `y`, the index is 26, but since the string is only 26 chars
                      // long, Japt wraps around and grabs the first char in the string.

Il risultato è un array di caratteri a questo punto, quindi il -Pflag lo unisce in una singola stringa e il risultato viene implicitamente inviato all'output.

Gelatina , 40 byte

Æfḟ2ÆCṚ⁸Ḃ¤¡Ṛị“YSPMFLQUIXNCWORAGZTEJHVDBK

Provalo online!

Verifica tutti i test in una volta! (leggermente modificato)

Pyth , 54 47 byte

7 byte grazie a isaacg

s__W%Q2@L."AZ❤O❤❤❤❤❤❤Q❤9❤❤×❤❤"xL_MP#r_3_103-PQ2

(❤ rappresenta un carattere non stampabile)

Pyth non ha molti incorporati principali ...

hexdump:

0000000: 73 5f 5f 57 25 51 32 40 4c 2e 22 41 5a 03 4f f3 s__W%Q2@L."AZ.O.
0000010: 14 af 15 ed f5 51 90 39 d5 18 d7 20 a8 22 78 4c .....Q.9... ."xL
0000020: 5f 4d 50 23 72 5f 33 5f 31 30 33 2d 50 51 32    _MP#r_3_103-PQ2

Provalo online!

J , 59 byte

'SPMFLQUIXNCWORAGZTEJHVDBKY'{~(p:>:i.26)i.[:|.@}.^:(2={.)q:

Provalo online!

Abbastanza semplice...

'SPMFLQUIXNCWORAGZTEJHVDBKY'{~(p:>:i.26)i.[:|.@}.^:(2={.)q:
                              (p:>:i.26)                      first 26 primes after 2
                                        i.                    for which the indices is
                                                         q:   prime factors
                                            |.@}.             remove first and reverse
                                                 ^:           if
                                                   (2={.)     the first entry is 2
                            {~                                reverse index
'..........................'                                  hardcoded string

PHP, 173 byte

for($i=2;1<$n=&$argn;$n%$i?++$i:$r[]=$i.!$n/=$i)for($t=$i;$i>2&!$w[$i]&&$i%--$t;$t>2?:$w[$i]=SPMFLQUIXNCWORAGZTEJHVDBKY[$p++]);$r[0]>2?:rsort($r);foreach($r as$s)echo$w[$s];

Versione online

allargato

for($i=2;1<$n=&$argn; # loop till input is 1
$n%$i?++$i:$r[]=$i.!$n/=$i) #after loop add value to result if input is divisible and divide input
  for($t=$i;$i>2&!$w[$i]&&$i%--$t; # loop if number is gt 2 and not in letter array till number is divisible 
  $t>2?:$w[$i]=SPMFLQUIXNCWORAGZTEJHVDBKY[$p++]) # if is prime add to letter array
  ; # make nothing in the loop
$r[0]>2?:rsort($r); # reverse result array if 2 is in result array
foreach($r as$s) # loop result array
  echo$w[$s]; # Output 

PHP, 178 byte

for($z=2;$p<26;$t>1?:$w[$z]=SPMFLQUIXNCWORAGZTEJHVDBKY[$p++])for($t=++$z;$z%--$t;);for($i=2;1<$n=&$argn;)$n%$i?++$i:$r[]=$i.!$n/=$i;$r[0]>2?:rsort($r);foreach($r as$s)echo$w[$s];

Versione online

allargato

for($z=2;$p<26;
$t>1?:$w[$z]=SPMFLQUIXNCWORAGZTEJHVDBKY[$p++]) # after loop if is prime add to letter array
  for($t=++$z;$z%--$t;); 
for($i=2;1<$n=&$argn;)  # loop till input is 1
  $n%$i?++$i:$r[]=$i.!$n/=$i; #add value to result if input is divisible and divide input
$r[0]>2?:rsort($r); # reverse result array if 2 is in result array
foreach($r as$s) # loop result array
  echo$w[$s]; # Output 

Python, 1420 byte

lambda x:(lambda a,b,e,k,l,m,q,p:len.__name__[:a].join(dict(zip((lambda n:(lambda n,f,g:f(n,e,[],f,g))(n,lambda n,i,r,f,g:g(n,i+b,r,f,g)if i<n else r,lambda n,i,r,f,g:f(n,i,[r,r+[i]][all(i%x!=a for x in[e]+r)],f,g)))(l*e*(k*l+b)),(lambda n,o,t:(lambda n,f,g:f(n, len.__name__[:a],f,g))(n,lambda n,s,f,g:g(n,s,f,g)if n>o else s,lambda n,s,f,g:f(n//t,s+chr(n%t),f,g)))((((((k<<e)-b)<<m)+m)<<((k<<q)+(k<<b)))+(((((k<<e)-b)<<e)+b)<<((k<<q)-(b<<b)))+((((((b<<k)+b))<<l)+b)<<((((k<<e)-b)<<l)+(b<<b)))+(((((k<<e)-b)<<l)-k)<<((m<<m)+p))-(((p<<m)-b)<<((m<<m)-(b<<b)))+(((m<<k)+b)<<((((m<<e)-b)<<k)-(b<<b)))+(((((k<<e)-b)<<l)-m)<<((((b<<l)+b)<<k)+k))-(((((b<<l)-b)<<l)-p)<<((b<<p)+(b<<b)))-(((p<<k)-b)<<((((b<<l)-b)<<k)+k))-(((k<<q)-b)<<((p<<l)))+(((m<<m)+m)<<((((k<<e)+b)<<k)-b))-(((k<<m)+b)<<((k<<m)-b))-(((m<<m)+k)<<((((k<<e)-b)<<k)-(b<<b)))+(((((k<<e)+b)<<e)+b)<<((m<<l)-(b<<e)))-(((((k<<e)+b)<<e)+b)<<((((b<<l)+b)<<e)-b))+((((((b<<k)+b))<<k)+b)<<((p<<k)))+(((((k<<e)-b)<<k)-k)<<((k<<l)))+(((m<<l)+b)<<((m<<k)))+(((m<<e)-b)<<((b<<m)+(b<<b)))+((((((b<<k)+b))<<e)-b)<<((k<<k)+b))+(((m<<k)-b)<<((b<<l)+b))-((((k<<e)-b))<<((k<<e)))+(((m<<e)+b)<<e)-b,b,b<<l*e)))[i]for i in(lambda x: [x.remove(e), x[::-b]][b] if e in x else x)((lambda x:(lambda x,g,h:g(x,b,[],g,h))(x,lambda x,n,r,g,h:h(x,n+b,r,g,h)if x>b else r,lambda x,n,r,g,h:h(x//n,n,r+[n],g,h)if x%n==a else g(x,n,r,g,h)))(x))))(*[x for x in range(True<<len(len.__name__))])

Questo potrebbe sicuramente accorciarne alcuni, ma è il mio tentativo di risolverlo senza numeri o letterali di stringa. Mi rendo conto che questo è un problema di code-golf e questo non è esattamente breve ma volevo condividere comunque, non sono sicuro che questo rompa le regole o meno.

È stato molto divertente da realizzare, ho usato l'algoritmo in questo post del blog per ridurre la rappresentazione numerica ASCII di "SPMFLQUIXNCWORAGZTEJHVDBKY" nell'espressione bit-shift che uso. In genere ho anche preso molta ispirazione da questo blog, volevo provarlo da solo e questa mi è sembrata una bella sfida.

Ecco una versione leggermente più leggibile, con anche alcuni nomi di variabili più sensibili