Vamos tentar de novo.

O objetivo deste concurso é criar dois pedaços de código que sejam anagramas um do outro (os dois devem conter os mesmos bytes em uma ordem diferente) e executarão as seguintes tarefas:

• É preciso testar se um número digitado é feliz ou primo e gerar saída se o número for (por exemplo, 7deve gerar happy primee 4produzir sad non-prime).

• O outro deve produzir seu tamanho de código em bytes como uma palavra (um programa de 60 bytes seria produzido sixty, um programa de 39 bytes thirty-nine).

Se for necessário algum esclarecimento sobre as regras, não hesite em me dizer.

Esta é uma competição de golfe com código, e o programa mais curto vence!

CJam, 80 49 48 caracteres

UPDATE : Inspirado na implementação de Dennis para calcular a soma dos quadrados dos dígitos, aqui está uma versão mais curta

Feliz / Triste Prime / Não Prime:

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

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

quarenta e oito

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

Como isso funciona:

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

Experimente online

O primeiro programa lê o número de STDIN

Minha solução original de 80 caracteres

Feliz / Triste Prime / Não Prime:

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

oitenta

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

CJam, 50 49 bytes

Teste de felicidade e primalidade

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

Lê um número de STDIN. Ambos os testes funcionam apenas para números inteiros de 64 bits.

Experimente online.

Comprimento próprio

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

Imprime para os nove e nove .

Golfscript - 81

Este programa testa se um número é feliz e / ou primo.

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

Este programa, um anagrama do último, gera "oitenta e um" (seu tamanho de bytes como uma palavra).

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

Isso deve servir como um exemplo.

J - 87 char

Uma tentativa ingênua disso em J. Nenhum uso da biblioteca padrão, embora eu duvide que seria mais curto usando isso.

((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'"_)

A linha no topo é um verbo pegando um número inteiro e diagnosticando sua felicidade e primalidade como uma sequência de saída. A segunda linha é uma expressão retornando a string eighty-seven, enquanto a terceira é uma função constante fazendo o mesmo. Incluí os dois porque ambos são possíveis e porque não sei qual será a decisão sobre as respostas das funções em oposição às respostas dos programas, e J não possui funções sem argumentos - você apenas atribui uma função a argumento fictício.

Perdemos a maioria dos caracteres procurando por felicidade. (,[:+/@:*:,.&.":@{:)é o corpo principal que soma os quadrados dos dígitos de um número e (1-{:e.}:)é o teste para determinar se esse número já ocorreu. sad`happy{~1 e.transforma isso em um resultado de palavra e o anexamos à frente da string non-prime, potencialmente cortando quatro caracteres se o número era realmente primo.

No anagrama, apenas escondemos todos os bits que não estão 'eighty-seven'em uma string que ignoramos. Eu poderia fazer melhor se J tivesse mais cartas para reutilizar, mas não, então tudo bem.