Su tarea es traducir un número liso 103 a una palabra en inglés, utilizando el método que se describe a continuación.

¿Cómo?

1. Genere la lista de factores primos (con repetición) del número de entrada.
2. Ordenar la lista:
   • Si 2 no es uno de los factores primos, ordene la lista en orden ascendente.
   • Si 2 es uno de los factores primos, elimínelo de la lista y ordene los factores restantes en orden descendente.

3. Traduzca cada factor a una letra, usando la siguiente tabla:

    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 : Esta tabla fue construida empíricamente para maximizar el número de palabras posibles. Para los curiosos, aquí hay una lista de 2,187 palabras que pueden codificarse de esa manera (puede incluir lenguaje grosero). Definitivamente no se garantiza que sea óptimo, pero es lo suficientemente bueno para este desafío.}

Ejemplos

Ejemplo 1: 579085261 (orden ascendente)

1. Los factores primos son [37, 47, 53, 61, 103] .
2. 2 no es un factor primo, por lo que mantenemos la lista ordenada en orden ascendente.
3. 37 = C, 47 = R, etc. La salida es "CRAZY".

Ejemplo 2: 725582 (orden descendente)

1. Los factores primos son [2, 11, 13, 43, 59] .
2. 2 es un factor primo, por lo que lo eliminamos y ordenamos la lista en orden descendente, lo que da:
   [59, 43, 13, 11] .
3. 59 = G, 43 = O, etc. La salida es "GOLF".

Ejemplo 3: 10757494 (con un factor repetido)

1. Los factores primos son [2, 11, 71, 71, 97] .
2. 2 es un factor primo, por lo que lo eliminamos y ordenamos la lista en orden descendente, lo que da:
   [97, 71, 71, 11] .
3. 97 = B, 71 = E, 11 = F. La salida es "BEEF".

Aclaraciones y reglas.

• Se garantiza que el número de entrada será 103-suave y divisible por 2 como máximo una vez.
• Por definición, un número liso es un entero positivo .
• La entrada y salida se pueden manejar en cualquier formato razonable. La salida puede estar en minúsculas o mayúsculas. El espacio en blanco al final es aceptable. El espacio en blanco principal no lo es.
• Si su programa / función no puede admitir entradas grandes, especifíquelo en su respuesta.
• Este es el código de golf, por lo que gana la respuesta más corta en bytes.

Casos de prueba

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

Jalea , 29 27 bytes

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

¡Gracias a @JonathanAllan por jugar golf en 1 byte!

Pruébalo en línea!

Fondo

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

es un literal numérico Los caracteres entre las comillas se reemplazan con sus índices basados ​​en 1 en la página de códigos Jelly , y la matriz resultante se interpreta como un número base-250. Esto produce el número entero c: = 288824892868083015619552399 .

Cómo funciona

Æ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.

Jalea , 36 bytes

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

Pruébalo en línea!

Explicación

Constante auxiliar1£ (produce “SPMFLQUIXNCWORAGZTEJHVDBKY ”con un 1 antepuesto)

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

Programa principal

×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

Tengo la sensación de que mi compresión de la lista supera fácilmente a la otra respuesta de Jelly, pero que mi algoritmo para usarla podría ser mucho más eficiente. Quizás intente combinarlos.

Jelly , 31 bytes, inspirada en la respuesta de @ Leakynun

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

Pruébalo en línea! (ligeramente modificado para correr mucho más rápido)

No es coherente si imprime una nueva línea final (pero PPCG normalmente permite respuestas con o sin una nueva línea final, así que supongo que esto también funciona). Es muy lento (O ( n ) donde n es la entrada, y esos números no son exactamente pequeños ...)

Explicación

Constante auxiliar1£ (produce “¶SPMFLQUIXNCWORAGZTEJHVDBKY”, donde ¶está la nueva línea)

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

Programa principal

Æ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 bytes

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

Utiliza la codificación CP-1252 . Pruébalo en línea!

Python 2, 220 217 bytes

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])

Pruébelo en línea : solo ejecuta el caso de prueba más pequeño sin quedarse sin memoria

Sin golf:

Esta versión no se usa exec, por lo que puede probar todos los casos de prueba sin quedarse sin 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)

Pruébalo en línea

Rubí , 139 138 134 125 120 115 + 7 = 146 145 141 132 127 122 bytes

Utiliza la -rprimebandera para +7 bytes.

-1 byte de @daniero. -4 bytes recordando que solo puedo hacer una verificación de divisibilidad regular en lugar de verificar la existencia de la división principal 2.

-9 bytes de la solución Python de @ mbomb007 que me recuerda una forma más corta de recuperar la letra correspondiente.

-5 bytes porque ahora se permite el espacio en blanco final.

-5 bytes de descubrimiento 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}*''}

Pruébalo en línea! (todos los casos de prueba)

Explicación

->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 + GNU utilities + bsd-games package, 170

Parece bastante no óptimo, pero funciona:

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

Pruébalo en línea .

Jalea , 33 bytes

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

Pruébalo en línea!

Japt , 51 50 bytes

49 bytes de código, +1 para la -Pbandera.

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

Pruébalo en línea!

Esto podría ser mucho más corto si solo Japt tuviera un par de características más ...

Explicación

`yspmflquixncÙgz’jhvdbk`es la misma cadena que todos los demás usan comprimida tanto como Japt puede comprimirla (¡3 bytes más cortos que el original!). La única herramienta de compresión integrada de Japt en este momento reemplaza los pares comunes de letras minúsculas con un carácter de un solo byte.

Así que examinemos el código real:

%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.

Luego £se utiliza para reemplazar cada elemento Xen el resultado de esta manera:

"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.

El resultado es una matriz de caracteres en este punto, por lo que el -Pindicador se une en una sola cadena y el resultado se envía implícitamente a la salida.

Jalea , 40 bytes

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

Pruébalo en línea!

¡Verifique todas las cajas de prueba a la vez! (ligeramente modificado)

Pyth , 54 47 bytes

7 bytes gracias a isaacg

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

( ❤representa un carácter no imprimible)

Pyth no tiene muchas características integradas principales ...

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

Pruébalo en línea!

J , 59 bytes

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

Pruébalo en línea!

Bastante sencillo...

'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 bytes

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];

Versión en línea

Expandido

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 bytes

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];

Versión en línea

Expandido

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 bytes

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__))])

Esto definitivamente podría acortar algunos, pero es mi intento de resolverlo sin números o literales de cadena. Me doy cuenta de que este es un problema de código de golf y esto no es exactamente corto, pero quería compartirlo de todos modos, no estoy seguro de si esto rompe alguna regla o no.

Fue muy divertido de hacer, utilicé el algoritmo en esta publicación de blog para reducir la representación numérica ASCII de "SPMFLQUIXNCWORAGZTEJHVDBKY" en la expresión de cambio de bits que uso. En general, también me inspiré mucho en este blog, quería probarlo yo mismo y parecía un buen desafío hacerlo.

Aquí hay una versión ligeramente más legible, con algunos nombres de variables más sensibles también