Essayons à nouveau.

Le but de ce concours est de créer deux morceaux de code qui sont des anagrammes l'un de l'autre (les deux doivent contenir les mêmes octets dans un ordre différent), et ils effectueront les tâches suivantes:

• Il faut tester si un nombre entré est heureux ou premier , et sortir si le nombre est soit (par exemple, 7doit sortir happy primeet 4doit sortir sad non-prime).

• L'autre doit sortir sa taille de code en octets sous forme de mot (un programme de 60 octets sortirait sixty, un programme de 39 octets sortirait thirty-nine).

Si des éclaircissements sont nécessaires sur les règles, n'hésitez pas à me le dire.

Il s'agit d'une compétition de golf de code, donc le programme le plus court gagne!

CJam, 80 49 48 caractères

MISE À JOUR : Inspiré par l'implémentation de Dennis pour calculer la somme des carrés des chiffres, voici une version plus courte

Heureux / Triste Prime / Non-prime:

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

Comment ça fonctionne:

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"

quarante huit

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

Comment cela fonctionne:

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

Essayez-le en ligne

Le premier programme lit le numéro de STDIN

Ma solution originale de 80 caractères

Heureux / 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

quatre-vingts

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

CJam, 50 49 octets

Test de bonheur et de primalité

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

Lit un nombre de STDIN. Les deux tests ne fonctionnent que pour les entiers 64 bits.

Essayez-le en ligne.

Propre longueur

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

Imprime pourTy-nine .

Golfscript - 81

Ce programme teste si un nombre est heureux et / ou premier.

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

Ce programme, une anagramme du dernier, produit "quatre-vingt-un" (sa taille octet en tant que mot).

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

Cela devrait servir d'exemple.

J - 87 car

Une tentative naïve à ce sujet dans J. Pas d'utilisation de la bibliothèque standard, bien que je doute qu'elle se raccourcisse en l'utilisant.

((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 ligne en haut est un verbe prenant un entier et diagnostiquant son bonheur et sa primauté en tant que chaîne de sortie. La deuxième ligne est une expression renvoyant la chaîne eighty-seven, tandis que la troisième est une fonction constante faisant de même. J'ai inclus les deux parce qu'ils étaient tous les deux possibles et parce que je ne sais pas quelle sera la décision sur les réponses de fonction par opposition aux réponses de programme, et J n'a pas de fonctions sans argument - vous donnez simplement une fonction argument factice.

Nous perdons la plupart des caractères vérifiant le bonheur. (,[:+/@:*:,.&.":@{:)est le corps principal qui additionne les carrés des chiffres d'un nombre, et (1-{:e.}:)est le test pour savoir si ce nombre s'est déjà produit. sad`happy{~1 e.transforme cela en un résultat de mot, et nous l'attachons à l'avant de la chaîne non-prime, coupant potentiellement quatre caractères si le nombre était réellement premier.

Dans l'anagramme, nous masquons simplement tous les bits qui ne sont pas 'eighty-seven'dans une chaîne que nous ignorons. Je pourrais faire mieux si J avait plus de lettres à réutiliser, mais ce n'est pas le cas, alors eh bien.