Un numero felice è definito dal seguente processo. Cominciando con qualsiasi numero intero positivo, sostituisci il numero con la somma dei quadrati delle sue cifre e ripeti il ​​processo fino a quando il numero è uguale a 1 (dove rimarrà), oppure si avvolge all'infinito in un ciclo che non include 1. Quei numeri per cui questo processo termina in 1 sono numeri felici, mentre quelli che non terminano in 1 sono numeri infelici (o numeri tristi). Dato un numero stampa se è felice o infelice.

Sample Inputs
7
4
13

Sample Outputs
Happy
Unhappy
Happy

Nota: il programma non dovrebbe richiedere più di 10 secondi per un numero inferiore a 1.000.000.000.

Golfscript - 34 caratteri

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

Fondamentalmente lo stesso di questo e questi .

Il motivo di 9 iterazioni è descritto in questi commenti (ciò restituisce teoricamente valori corretti fino a circa 10^10^10^974( A001273 )).

Rubino, 77 caratteri

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");}

Questo utilizza un array da 2 ³⁰ byte (1 GB) come bitmap per tenere traccia di quali numeri sono stati rilevati nel ciclo. Su Linux, questo funziona davvero, e in modo efficiente, a condizione che sia abilitato il sovraccarico di memoria (che di solito è di default). Con il commit eccessivo, le pagine dell'array vengono allocate e azzerate su richiesta.

Nota che la compilazione di questo programma su Linux utilizza un gigabyte di 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 caratteri

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

Ogni numero felice converge in 1; ogni numero infelice converge in un ciclo contenente 4. Oltre a sfruttare questo fatto, questo è a malapena a golf.

(Grazie a Ventero, dalla cui soluzione Ruby ho scritto un trucco e ho salvato 6 caratteri).

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

Chiamato come etex filename.tex 34*23 + 32/2 ?(incluso il punto interrogativo alla fine). Gli spazi nell'espressione non contano.

EDIT: sono arrivato a 123 , ma ora l'output è dvi (se compilato con etex) o pdf (se compilato con pdfetex). Dato che TeX è un linguaggio tipografico, credo sia giusto.

\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 caratteri

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

Qualche ispirazione presa da Ventero e 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'immissione viene fornita impostando a sul numero desiderato.

Crediti a mellamokb.

Python (98, ma troppo incasinato per non condividere)

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

Modo, troppo tempo per essere competitivo, ma forse buono per una risata. Fa una valutazione "pigra" in Python. Davvero abbastanza simile alla voce di Haskell ora che ci penso, solo senza il fascino.

dc - 47 caratteri

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

Breve descrizione:

I~: Ottiene il quoziente e il resto quando si divide per 10
d*.: quadrare il resto.
0<H: Se il quoziente è maggiore di 0, ripetere in modo ricorsivo.
+: Somma i valori quando si riduce la pila ricorsiva.

4<h: Ripete il bit della somma dei quadrati mentre il valore è maggiore di 4.

Befunge, 109

Restituisce i valori corretti per 1 <= n <= 10 ⁹ -1.

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

J, 56

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

Un verbo piuttosto che uno script autonomo poiché la domanda è ambigua.

Uso:

   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 caratteri

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)@":)

Sono sicuro che un J-er più competente di quanto possa renderlo ancora più breve. Sono un newb relativo.

Nuovo e migliorato:

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

Più recenti e ancora più migliorati, grazie a ɐɔıʇǝɥʇuʎs:

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

Python (91 caratteri)

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

Lisp comune 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"))))

Più leggibile:

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

Sarebbe più breve restituire "Happy" o "Unhappy" fin (do)dall'inizio, ma probabilmente non conterebbe come un intero programma

K, 43

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

Gelatina , 17 byte (non competitiva *)

* Sfida post-lingua in lingua

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

Provalo online!

Come?

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 byte

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

$ n è il valore di input

05AB1E , 21 byte

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

Provalo online o verifica i primi 100 casi di test .

Spiegazione:

Ogni numero alla fine si tradurrà in uno 1o 4, quindi eseguiamo il ciclo indefinitamente e ci fermiamo non appena il numero è inferiore a 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)

Vedere questo suggerimento 05AB1E mio (sezione Come utilizzare il dizionario? ) Per capire il motivo per cui 'ŽØè "happy".

C ++ 135, 2 righe

#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";}

Questa è una versione modificata di quella che ho fatto qui:

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

Sì, questa sfida ha tre anni; sì, ha già una risposta vincente; ma dato che ero annoiato e ho fatto questo per un'altra sfida, ho pensato di poterlo mettere qui. Sorpresa sorpresa, è lunga - e in ...

Java - 280 264 byte

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);}}

Ungolfed:

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);
        }
    }
}

94 byte C #

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));

Per ogni dato numero (as int), h()verrà restituito il valore corretto. Puoi provare il codice su .NetFiddle .

Complimenti per l' utente sconosciuto per l' algoritmo originale .

Clojure, 107 97 byte

Aggiornamento: rimosso l' letassociazione non necessaria .

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

Originale:

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

Prima volta usando un nidificato for: o

R, 117 91 byte

-16 byte grazie a 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 byte

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

Provalo online!

Python 2 , 71 byte

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

Provalo online!

... o, per lo stesso conteggio byte:

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

Provalo online!

C: 1092 caratteri

#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 ;
}