Proviamo di nuovo.

Lo scopo di questo concorso è quello di creare due pezzi di codice che siano anagrammi l'uno dell'altro (i due devono contenere gli stessi byte in un ordine diverso) e faranno i seguenti compiti:

• Uno deve verificare se un numero immesso è felice o primo e emettere se il numero è uno (ad esempio, 7deve emettere happy primee 4deve emettere sad non-prime).

• L'altro deve emettere la sua dimensione di codice in byte come una parola (un programma da 60 byte emetterebbe sixty, un programma da 39 byte emetterebbe thirty-nine).

Se è necessario chiarire le regole, non esitate a dirmelo.

Questa è una competizione di codice golf, quindi vince il programma più breve!

CJam, 80 49 48 caratteri

AGGIORNAMENTO : ispirato dall'implementazione di Dennis per calcolare la somma dei quadrati delle cifre, ecco una versione più breve

Felice / Triste Prime / Non prime:

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

Come funziona:

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"

quarantotto

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

Come funziona:

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

Provalo online

Il primo programma legge il numero da STDIN

La mia soluzione originale di 80 caratteri

Felice / Triste 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

ottanta

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

CJam, 50 49 byte

Test di felicità e primalità

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

Legge un numero da STDIN. Entrambi i test funzionano solo per numeri interi a 64 bit.

Provalo online.

Propria lunghezza

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

Stampa per le nove .

Golfscript - 81

Questo programma verifica se un numero è felice e / o primo.

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

Questo programma, un anagramma dell'ultimo, produce "ottantuno" (il suo byte come una parola).

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

Questo dovrebbe servire da esempio.

J - 87 caratteri

Un ingenuo tentativo in questo in J. Nessun uso della libreria standard, anche se dubito che sarebbe più breve usando quello.

((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 linea in alto è un verbo che prende un numero intero e ne diagnostica la felicità e la primalità come stringa di output. La seconda riga è un'espressione che restituisce la stringa eighty-seven, mentre la terza è una funzione costante che fa lo stesso. Ho incluso entrambi perché erano entrambi possibili e perché non so quale sarà la sentenza sulle risposte delle funzioni rispetto a quelle del programma, e J non ha una funzione come nessuna discussione - date semplicemente una funzione a argomento fittizio.

Perdiamo la maggior parte dei caratteri per verificare la felicità. (,[:+/@:*:,.&.":@{:)è il corpo principale che somma i quadrati delle cifre di un numero ed (1-{:e.}:)è il test per verificare se quel numero si è ancora verificato. sad`happy{~1 e.trasforma questo in un risultato di parola e lo alleghiamo all'inizio della stringa non-prime, eliminando potenzialmente quattro caratteri se il numero fosse effettivamente primo.

Nell'anagramma nascondiamo solo tutti i bit che non sono 'eighty-seven'in una stringa che ignoriamo. Potrei fare di meglio se J avesse più lettere da riutilizzare, ma non è così, quindi vabbè.