Un nombre heureux est défini par le processus suivant. En commençant par n'importe quel entier positif, remplacez le nombre par la somme des carrés de ses chiffres et répétez le processus jusqu'à ce que le nombre soit égal à 1 (où il restera), ou il boucle sans fin dans un cycle qui ne comprend pas 1. Ces nombres pour lesquels ce processus se termine par 1 sont des nombres heureux, tandis que ceux qui ne se terminent pas par 1 sont des nombres malheureux (ou des nombres tristes). Étant donné un numéro, indiquez s'il est heureux ou non.

Sample Inputs
7
4
13

Sample Outputs
Happy
Unhappy
Happy

Remarque: Votre programme ne devrait pas prendre plus de 10 secondes pour tout nombre inférieur à 1 000 000 000.

Golfscript - 34 caractères

~{0\`{48-.*+}/}9*1="UnhH"3/="appy"

Fondamentalement les mêmes que ceux- ci et ceux - ci .

La raison de 9 itérations est décrite dans ces commentaires (cela renvoie théoriquement des valeurs correctes jusqu'à environ 10^10^10^974( A001273 )).

Ruby, 77 caractères

a=gets.to_i;a=eval"#{a}".gsub /./,'+\&**2'until a<5
puts a<2?:Happy: :Unhappy

C - 115

char b[1<<30];a;main(n){for(scanf("%d",&n);b[n]^=1;n=a)for
(a=0;a+=n%10*(n%10),n/=10;);puts(n-1?"Unhappy":"Happy");}

Cela utilise un 2 tableau de ³⁰ octets (1 Go) comme bitmap pour garder une trace des numéros rencontrés au cours du cycle. Sous Linux, cela fonctionne réellement et efficacement, à condition que la surcharge de mémoire soit activée (ce qui est généralement le cas par défaut). En cas de surcharge, les pages du tableau sont allouées et remises à zéro à la demande.

Notez que la compilation de ce programme sous Linux utilise un gigaoctet de RAM.

Haskell - 77

f 1="Happy"
f 4="Unhappy"
f n=f$sum[read[c]^2|c<-show n]
main=interact$f.read

Golfscript, 49 43 41 40 39 caractères

~{0\10base{.*+}/.4>}do(!"UnhH"3/="appy"

Chaque nombre heureux converge vers 1; chaque nombre malheureux converge vers un cycle contenant 4. En plus d'exploiter ce fait, c'est à peine joué au golf.

(Merci à Ventero, de la solution Ruby dont j'ai réussi une astuce et enregistré 6 caractères).

eTeX, 153

\let~\def~\E#1{\else{\fi\if1#1H\else Unh\fi appy}\end}~\r#1?{\ifnum#1<5
\E#1\fi~\s#1{0?}}~\s#1{+#1*#1\s}~~{\expandafter\r\the\numexpr}\message{~\noexpand

Appelé comme etex filename.tex 34*23 + 32/2 ?(y compris le point d'interrogation à la fin). Les espaces dans l'expression n'ont pas d'importance.

EDIT: je suis descendu à 123 , mais maintenant la sortie est dvi (si compilée avec etex) ou pdf (si compilée avec pdfetex). Puisque TeX est un langage de composition, je suppose que c'est juste.

\def~{\expandafter\r\the\numexpr}\def\r#1?{\ifnum#1<5 \if1#1H\else
Unh\fi appy\end\fi~\s#1{0?}}\def\s#1{+#1*#1\s}~\noexpand

Python - 81 caractères

n=input()
while n>4:n=sum((ord(c)-48)**2for c in`n`)
print("H","Unh")[n>1]+"appy"

Une inspiration inspirée de Ventero et Peter Taylor.

Javascript ( 94 92 87 86)

do{n=0;for(i in a){n+=a[i]*a[i]|0}a=n+''}while(n>4);alert(['H','Unh'][n>1?1:0]+'appy')

L'entrée est fournie en réglant a sur le nombre souhaité.

Crédits à mellamokb.

Python (98, mais trop foiré pour ne pas partager)

f=lambda n:eval({1:'"H"',4:'"Unh"'}.get(n,'f(sum(int(x)**2for x in`n`))'))
print f(input())+"appy"

Bien trop long pour être compétitif, mais peut-être bon pour rire. Il fait une évaluation "paresseuse" en Python. Vraiment assez similaire à l'entrée Haskell maintenant que j'y pense, juste sans aucun charme.

dc - 47 caractères

[Unh]?[[I~d*rd0<H+]dsHxd4<h]dshx72so1=oP[appy]p

Brève description:

I~: Obtenez le quotient et le reste lorsque vous divisez par 10
d*.: Mettez le reste au carré.
0<H: Si le quotient est supérieur à 0, répétez récursivement.
+: Somme les valeurs lors de la réduction de la pile récursive.

4<h: Répéter le bit de somme des carrés lorsque la valeur est supérieure à 4.

Befunge, 109

Renvoie des valeurs correctes pour 1 <= n <= 10 ⁹ -1.

v v              <   @,,,,,"Happy"<      >"yppahnU",,,,,,,@
>&>:25*%:*\25*/:#^_$+++++++++:1-!#^_:4-!#^_10g11p

J, 56

'Happy'"_`('Unhappy'"_)`([:$:[:+/*:@:"."0@":)@.(1&<+4&<)

Un verbe plutôt qu'un script autonome car la question est ambiguë.

Usage:

   happy =: 'Happy'"_`('Unhappy'"_)`([:$:[:+/*:@:"."0@":)@.(1&<+4&<)
happy =: 'Happy'"_`('Unhappy'"_)`([:$:[:+/*:@:"."0@":)@.(1&<+4&<)
   happy"0 (7 4 13)
happy"0 (7 4 13)
Happy  
Unhappy
Happy  

Scala, 145 caractères

def d(n:Int):Int=if(n<10)n*n else d(n%10)+d(n/10)
def h(n:Int):Unit=n match{
case 1=>println("happy")
case 4=>println("unhappy")
case x=>h(d(x))}

J (50)

'appy',~>('Unh';'H'){~=&1`$:@.(>&6)@(+/@:*:@:("."0)@":)

Je suis sûr qu'un J-er plus compétent que je ne peux le rendre encore plus court. Je suis relativement nouveau.

Nouveau et amélioré:

('Unhappy';'Happy'){~=&1`$:@.(>&6)@(+/@:*:@:("."0)@":)

Plus récent et encore plus amélioré, grâce aux ɐɔıʇǝɥʇuʎs:

(Unhappy`Happy){~=&1`$:@.(>&6)@(+/@:*:@:("."0)@":)

Python (91 caractères)

a=lambda b:b-1and(b-4and a(sum(int(c)**2for c in`b`))or"Unh")or"H";print a(input())+"appy"

Common Lisp 138

(format t"~Aappy~%"(do((i(read)(loop for c across(prin1-to-string i)sum(let((y(digit-char-p c)))(* y y)))))((< i 5)(if(= i 1)"H""Unh"))))

Plus lisible:

(format t "~Aappy~%"
        (do
          ((i (read)
              (loop for c across (prin1-to-string i)
                    sum (let
                          ((y (digit-char-p c)))
                          (* y y)))))
          ((< i 5) (if (= i 1) "H" "Unh"))))

Serait plus court pour renvoyer juste "Heureux" ou "Malheureux" directement depuis le (do), mais sans doute cela ne compterait pas comme un programme entier

K, 43

{{$[4=d:+/a*a:"I"$'$x;unhappy;d]}/x;`happy}

Gelée , 17 octets (hors compétition *)

* Défi linguistique post-dates

D²SµÐLỊị“¢*X“<@Ḥ»

Essayez-le en ligne!

Comment?

D²SµÐLỊị“¢*X“<@Ḥ» - Main link: n
   µÐL            - loop while the accumulated unique set of results change:
D                 -   cast to a decimal list
 ²                -   square (vectorises)
  S               -   sum
                  - (yields the ultimate result, e.g. n=89 yields 58 since it enters the
                  -  "unhappy circle" at 145, loops around to 58 which would yield 145.)
      Ị           - insignificant? (abs(v)<=1 - in this case, 1 for 1, 0 otherwise)
        “¢*X“<@Ḥ» - dictionary lookup of ["Happy", "Unhappy"] (the central “ makes a list)
       ị          - index into
                  - implicit print

Perl 5-77 octets

{$n=$_*$_ for split//,$u{$n}=$n;exit warn$/.'un'[$n==1].'happy'if$u{$n};redo}

$ n est la valeur d'entrée

05AB1E , 21 octets

'ŽØs[SnOD5‹#}≠i„unì}™

Essayez-le en ligne ou vérifiez les 100 premiers cas de test .

Explication:

Chaque nombre entraînera éventuellement l'un 1ou l' autre 4, nous bouclons donc indéfiniment et nous nous arrêtons dès que le nombre est inférieur à 5.

'ŽØ                    '# Push string "happy"
   s                    # Swap to take the (implicit) input
    [       }           # Loop indefinitely
     S                  #  Convert the integer to a list of digits
      n                 #  Square each
       O                #  Take the sum
        D5‹#            #  If this sum is smaller than 5: stop the infinite loop
             ≠i    }    # If the result after the loop is NOT 1:
               „unì     #  Prepend string "un" to string "happy"
                    ™   # Convert the string to titlecase (and output implicitly)

Voir cette astuce de la mine de 05AB1E (section Comment utiliser le dictionnaire? ) Pour comprendre pourquoi 'ŽØest "happy".

C ++ 135, 2 lignes

#include<iostream>
int n,i,j;int main(){for(std::cin>>n;n>1;n=++j&999?n*n+i:0)for(i=0;n/10;n/=10)i+=n%10*(n%10);std::cout<<(n?"H":"Unh")<<"appy";}

Ceci est une version modifiée de celle que j'ai faite ici:

/programming/3543811/code-golf-happy-primes/3545056#3545056

Oui, ce défi a trois ans; oui, il a déjà une réponse gagnante; mais comme je m'ennuyais et que je faisais cela pour un autre défi, j'ai pensé que je pourrais le mettre ici. Surprise surprise, c'est long - et en ...

Java - 280 264 octets

import java.util.*;class H{public static void main(String[]a){int n=Integer.parseInt(new Scanner(System.in).nextLine()),t;while((t=h(n))/10!=0)n=t;System.out.print(t==1?"":"");}static int h(int n){if(n/10==0)return n*n;else return(int)Math.pow(n%10,2)+h(n/10);}}

Non golfé:

import java.util.*;

class H {

    public static void main(String[] a) {
        int n = Integer.parseInt(new Scanner(System.in).nextLine()), t;
        while ((t = h(n)) / 10 != 0) {
            n = t;
        }
        System.out.print(t == 1 ? "" : "");
    }

    static int h(int n) {
        if (n / 10 == 0) {
            return n * n;
        } else {
            return (int) Math.pow(n % 10, 2) + h(n / 10);
        }
    }
}

C # 94 octets

int d(int n)=>n<10?n*n:(d(n%10)+d(n/10));string h(int n)=>n==1?"happy":n==4?"unhappy":h(d(n));

Pour tout nombre donné (as int), h()renvoie la valeur correcte. Vous pouvez essayer le code sur .NetFiddle .

Félicitations à l' utilisateur inconnu pour l' algorithme d' origine .

Clojure, 107 97 octets

Mise à jour: suppression de la letliaison inutile .

#(loop[v %](case v 1"Happy"4"Unhappy"(recur(apply +(for[i(for[c(str v)](-(int c)48))](* i i))))))

Original:

#(loop[v %](let[r(apply +(for[i(for[c(str v)](-(int c)48))](* i i)))](case r 1"Happy"4"Unhappy"(recur r))))

Première utilisation d'un imbriqué for: o

R, 117 91 octets

-16 octets grâce à Giuseppe

a=scan();while(!a%in%c(1,4))a=sum((a%/%10^(0:nchar(a))%%10)^2);`if`(a-1,'unhappy','happy')

Perl 5 , 62 + 1 ( -p) = 63 octets

$_=eval s/./+$&**2/gr while$_>1&&!$k{$_}++;$_=un x($_>1).happy

Essayez-le en ligne!

Python 2 , 71 octets

f=lambda n:n>4and f(sum(int(d)**2for d in`n`))or("H","Unh")[n>1]+"appy"

Essayez-le en ligne!

... ou, pour le même nombre d'octets:

f=lambda n:n>4and f(eval('**2+'.join(`n*10`)))or("H","Unh")[n>1]+"appy"

Essayez-le en ligne!

C: 1092 caractères

#include <iostream>
using namespace std ;
int main ()
{
    int m , a[25] , kan=0 , y , z=0  , n , o=0, s , k=0 , e[25]  ;
    do {
m :
        for ( int j=1 ; j <10000 ; j++ )
        {   
n:
            for (int i=0 ; j!=0 ; i++ )
            {
                a[i]=j%10 ;
                j/=10 ;
                kan++ ;
            }
            for ( int i=0 ; i<kan ; i++ )
            {
                y=a[i]*a[i] ;
                z+=y ;
            }
            k+=1 ;
            if (z==1)
            {
              cout<<j<<endl;
               o++ ;
            }

            else 
            {   
                 for (int f=0 ; f<k ; f++ )
                 {
                     e[f]=z ;
                 }
                 for ( int f=0 ; f=k-1 ; f++ )
                 {
                     for ( int p=f+1 ; p <k-1 ; p++ )
                     {
                         if(e[f]=e[p])
                             goto m ;
                         else { j=z ; goto n ; } 
                     }
                 }
            }
        }
    }while(o!=100) ;
    return 0 ;
}