579085261 es LOCO, 725582 es GOLF, 10757494 es ...?

39

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
Arnauld
fuente
9
Ohhh porquería ... 05AB1E caché de respuesta de los comandos Òen 579085261, siente como <s> Emigna </ s> Adnan ya ha comenzado.
Magic Octopus Urn
Podrías haber permitido múltiples factores de 2, y luego haberlo hecho para que al aumentar el número de factores cambie el índice en el que comienza la reversión.
mbomb007
@ mbomb007 Sí, hay muchas variantes posibles. Mi idea inicial era codificar cualquier palabra trabajando en grupos de letras.
Arnauld
55
Los casos de prueba en este desafío recuerdan las cosas de "descubre tu nombre X" en Facebook. ¡Encuentra el título de la película en la que te encuentras! Paso uno, elige tu número primo favorito <=103... tu resultado es PIRATE MAZE, o DOOM VACUUMS...
mbomb007
2
@ Qwerp-Derp Primero se barajó al azar y se probó en un diccionario de ~ 106K palabras, hasta 11 letras (el archivo está en mi HD durante mucho tiempo; creo que se extrajo originalmente del TWL ). Luego forcé a 'S' a ser el primero o el último para maximizar las palabras en plural y probé un par de intercambios de letras individuales en una buena combinación (recursivamente). Finalmente, perdí la paciencia y escribí el desafío. :-) En realidad, antes de todo esto, traté de tener en cuenta los recuentos de letras por posición dentro de Word , pero no fue tan bueno.
Arnauld

Respuestas:

13

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.
Dennis
fuente
10

Jalea , 36 bytes

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

Pruébalo en línea!

Explicación

Constante auxiliar (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 auxiliar (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

fuente
Esa es una muy buena manera de almacenar una permutación del alfabeto ...
Leaky Nun
Ah, también has usado mi átomo de permutación: D
Jonathan Allan
9

05AB1E , 39 38 bytes

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

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

Adnan
fuente
8
Sabía que era uno de ustedes jajaja. raspaduras a mitad de camino terminado respuesta en la basura
Urna de pulpo mágico
66
@carusocomputing los éxitos de caché pueden traer algo de presión de tiempo jaja
Adnan
Øfue la parte de esto que superó la mía por 20 bytes de todos modos: P.
Magic Octopus Urn
2
No es muy eficiente, no;)
Emigna
8

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

mbomb007
fuente
8

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
Tinta de valor
fuente
Buena esa. Puede eliminar el espacio entre zipy"
daniero
7

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 .

Trauma digital
fuente
6

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.

ETHproducciones
fuente
5

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!

Monja permeable
fuente
@isaacg Lo probé, y no sé por qué produce un resultado extraño para el último.
Leaky Nun
No sé a qué te refieres: pyth.herokuapp.com/…
isaacg
@isaacg Eso es muy raro.
Leaky Nun
5

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
Conor O'Brien
fuente
3

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 
Jörg Hülsermann
fuente
1

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

Billyoyo
fuente
Hay al menos un espacio que se puede eliminar.
mbomb007
2
¡Bienvenido a Programming Puzzles & Code Golf! Esta es una competencia de código de golf, por lo que su objetivo debe ser hacer que su código sea lo más breve posible. Nuestro centro de ayuda afirma que todas las soluciones a los desafíos deben ser un [...] competidor serio para los criterios ganadores en uso. [...] Una entrada a un concurso de golf de código debe ser golfizada
Dennis