Código de anagrama

10

Intentemos esto de nuevo.

El objetivo de este concurso es hacer dos piezas de código que sean anagramas entre sí (las dos deben contener los mismos bytes en un orden diferente), y realizarán las siguientes tareas:

  • Uno debe probar si un número ingresado es feliz o primo , y generar si el número es cualquiera (por ejemplo, 7debe emitir happy primey 4debe emitir sad non-prime).

  • El otro debe generar su tamaño de código en bytes como una palabra (se generaría un programa de 60 bytes, se generaría sixtyun programa de 39 bytes thirty-nine).

Si necesita alguna aclaración sobre las reglas, no dude en decírmelo.

Esta es una competencia de código de golf, por lo que gana el programa más corto.

Josiah Winslow
fuente
¿Qué le impide a uno hacer /*program1*/program2y luego program1/*program2*/? Creo que deberías rechazar los comentarios.
William Barbosa
@WilliamBarbosa ¿Por qué? Eso difícilmente será una solución óptima.
Martin Ender
Pero también podría compartir algunas partes y no compartir otras, lo que lo hace mucho más fácil
orgulloso Haskeller
1
@proudhaskeller Prohibir comentarios no resuelve eso. Siempre puede insertar caracteres en cadenas, nombres de variables o partes del código que no se ejecutan por otros motivos.
Martin Ender
1
FWIW, no creo que debas haber eliminado tu propia presentación. OP o no, fue una respuesta interesante.
Dennis

Respuestas:

6

CJam, 80 49 48 caracteres

ACTUALIZACIÓN : inspirada en la implementación de Dennis para calcular la suma de cuadrados de dígitos, aquí hay una versión más corta

Happy / Sad Prime / Non-prime:

ri:T{Ab2f#:+}G*X="happy""sad"?STmp4*"non-prime">

Cómo funciona:

ri:T                                "Read input as integer and store it in T"
    {       }G*                     "Run this code block 16 times"
     Ab                             "Convert the number into base 10"
       2f#                          "Calculate square of each digit"
          :+                        "Sum all the squared digits and put the sum on stack"
X=                                  "Compare the sum after 16th iteration to 1"
  "happy""sad"?                     "If sum is 1, put `happy` to stack, otherwise `sad`"
               ST                   "Put space on stack then put the value of T on stack"
                 mp4*               "Put 4 to stack if input is prime, otherwise 0"
                     "non-prime">   "Put `non-prime` to stack and slice out first four characters if the input number is prime"

cuarenta y ocho

""A"forTy-eiGhT""ri:{b2#:+}*X=appsadSmp4*nnpm>"?

Cómo funciona esto:

""                                  "Push empty string to stack"
  A                                 "Push 10 to stack"
   "forTy-eiGhT"                    "Push `forTy-eiGhT` to stack"
                "ri:....pm>"        "Push this string to stack too"
                            ?       "Keep `forTy-eiGhT` on stack and pop the other string"

Pruébalo en línea

El primer programa lee el número de STDIN


Mi solución original de 80 caracteres

Happy / Sad Prime / Non-prime:

r:N{1/~]{i_*T+:T;}/T_s\1=:H!X):XK<&0:T;}g;H"happy""sad"?SNimp"prime"_"non-"\+?:Y

ochenta

"eigHTY""r:N{1/~]{i_*T+:T}/_s\1=:H!X):XK<&0:T}happysad?SNmp";"prim_";"non-\?:+";
Optimizador
fuente
4

CJam, 50 49 bytes

Test de felicidad y primalidad

li_{Ab2f#:+}30*(T="happy""sad"?S@mp4*"non-prime">

Lee un número de STDIN. Ambas pruebas funcionan solo para enteros de 64 bits.

Pruébalo en línea.

Longitud propia

A"forTy-nine""l_{b2#:+}30*(=happsadS@mp4*pim>"?""

Impresiones para trece y nueve .

Dennis
fuente
+1 para la mejora de 31 bytes y "paraTy nueve".
Josiah Winslow
3

Golfscript - 81

Este programa prueba si un número es feliz y / o primo.

~.:a;0.{).a\%!@+\}a*;2="""non-"if"prime"@ {`0\{48-.*+}/}9*("sad ""happy "if@@#get

Este programa, un anagrama del último, genera "ochenta y uno" (su tamaño de bytes es una palabra).

;"eighty-one"#   !""""""""%()***++-..../002489:;=@@@@\\\`aaaaadffiimnppprs{{{}}}~

Esto debería servir como un ejemplo.

Josiah Winslow
fuente
2
Hm, proporcionar una implementación de referencia para un desafío de golf de código en GolfScript podría no ser la mejor idea. Creo que este es bastante difícil de superar y, por lo tanto, un poco desalentador para los participantes.
Martin Ender
Veo que la gente no se da cuenta de que escribiste la pregunta y te votó ... Estoy totalmente de acuerdo con Martin.
orgulloso Haskeller
@proudhaskeller No hay absolutamente nada de malo en responder a sí mismo.
Justin
Digo que no hay nada de malo en responderme a mí mismo o comentar el código.
Josiah Winslow
2
@JosiahWinslow No tiene nada de malo. Solo digo que es posible que te estés perdiendo algunas respuestas interesantes más largas si publicas una muy buena solución de inmediato.
Martin Ender
1

J - 87 char

Un intento ingenuo de esto en J. Sin uso de la biblioteca estándar, aunque dudo que se acorte más al usar eso.

((sad`happy{~1 e.(,[:+/@:*:,.&.":@{:)^:(1-{:e.}:)^:_);@,' ';'gtv]non-prime'}.~4+4*1&p:)
'((ad`app{~1 .(,[:+/@:*:,.&.":@{:)^:(1-{:.}:)^:_);@, ;onprm}.~4+4*1&p:)']'eighty-seven'
('(ad`app{~1 .(,[:+/@:*:,.&.:@{:)^:(1-{:.}:)^:);@, ;onprm}.~4+4*1&p:']'eighty-seven'"_)

La línea en la parte superior es un verbo que toma un número entero y diagnostica su felicidad y primalidad como una cadena de salida. La segunda línea es una expresión que devuelve la cadena eighty-seven, mientras que la tercera es una función constante que hace lo mismo. Incluí ambos porque ambos eran posibles y porque no sé cuál será la decisión sobre las respuestas de la función en lugar de las del programa, y ​​J no tiene funciones que no contengan argumentos: simplemente le da a una función un argumento ficticio

Perdemos la mayoría de los caracteres que buscan la felicidad. (,[:+/@:*:,.&.":@{:)es el cuerpo principal que suma los cuadrados de los dígitos de un número, y (1-{:e.}:)es la prueba de si ese número ya ha ocurrido. sad`happy{~1 e.convierte esto en un resultado de palabra, y lo adjuntamos al frente de la cadena non-prime, potencialmente cortando cuatro caracteres si el número era realmente primo.

En el anagrama simplemente ocultamos todos los bits que no están 'eighty-seven'en una cadena que ignoramos. Podría hacerlo mejor si J tuviera más letras para reutilizar, pero no es así, así que bueno.

Algoritmo de tiburón
fuente
Esa es una buena solución.
Josiah Winslow