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.

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-\?:+";

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 .

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.

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.