Un número feliz se define mediante el siguiente proceso. Comenzando con cualquier número entero positivo, reemplace el número por la suma de los cuadrados de sus dígitos y repita el proceso hasta que el número sea igual a 1 (donde permanecerá), o se repite sin parar en un ciclo que no incluye 1. Esos números para los cuales este proceso termina en 1 son números felices, mientras que los que no terminan en 1 son números infelices (o números tristes). Dado un número, imprima si es feliz o infeliz.

Sample Inputs
7
4
13

Sample Outputs
Happy
Unhappy
Happy

Nota: Su programa no debería tomar más de 10 segundos para cualquier número por debajo de 1,000,000,000.

Golfscript - 34 caracteres

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

Básicamente lo mismo que esto y estos .

La razón de 9 iteraciones se describe en estos comentarios (esto teóricamente devuelve valores correctos hasta aproximadamente 10^10^10^974( A001273 )).

Ruby, 77 caracteres

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

Utiliza una matriz ^de 2 ³⁰ bytes (1 GB) como mapa de bits para realizar un seguimiento de los números que se han encontrado en el ciclo. En Linux, esto realmente funciona, y de manera eficiente, siempre y cuando se habilite el sobrecompromiso de memoria (que generalmente es por defecto). Con el exceso de compromiso, las páginas de la matriz se asignan y se ponen a cero bajo demanda.

Tenga en cuenta que compilar este programa en Linux usa un gigabyte 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 caracteres

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

Cada número feliz converge a 1; cada número infeliz converge a un ciclo que contiene 4. Además de explotar ese hecho, esto apenas se juega al golf.

(Gracias a Ventero, de cuya solución de Ruby he robado un truco y guardo 6 caracteres).

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

Llamado como etex filename.tex 34*23 + 32/2 ?(incluido el signo de interrogación al final). Los espacios en la expresión no importan.

EDITAR: bajé a 123 , pero ahora la salida es dvi (si está compilada con etex) o pdf (si está compilada con pdfetex). Dado que TeX es un lenguaje tipográfico, supongo que es justo.

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

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

Alguna inspiración tomada de Ventero y 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')

La entrada se proporciona estableciendo a en el número deseado.

Créditos a mellamokb.

Python (98, pero demasiado desordenado para no compartir)

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

Demasiado largo para ser competitivo, pero tal vez bueno para reír. Hace una evaluación "perezosa" en Python. Realmente bastante similar a la entrada de Haskell ahora que lo pienso, simplemente sin nada de encanto.

dc - 47 caracteres

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

Breve descripción:

I~: Obtenga el cociente y el resto al dividir por 10
d*.: Cuadre el resto.
0<H: Si el cociente es mayor que 0, repita recursivamente.
+: Suma los valores al reducir la pila recursiva.

4<h: Repite el bit de suma de cuadrados mientras el valor es mayor que 4.

Befunge, 109

Devuelve los valores correctos para 1 <= n <= 10 ⁹ -1.

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

J, 56

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

Un verbo en lugar de un guión independiente ya que la pregunta es 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 caracteres

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

Estoy seguro de que es un J-er más competente de lo que puedo hacer esto aún más corto. Soy un nuevo pariente.

Nuevo y mejorado:

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

Más nuevo e incluso más mejorado, gracias a ɐɔıʇǝɥʇuʎs:

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

Python (91 caracteres)

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

Lisp común 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"))))

Más legible:

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

Sería más corto simplemente devolver "Feliz" o "Infeliz" directamente desde el (do), pero podría decirse que eso no contaría como un programa completo

K, 43

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

Jalea , 17 bytes (no competidora *)

* Desafío post-fechas de idiomas

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

Pruébalo en línea!

¿Cómo?

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 Bytes

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

$ n es el valor de entrada

05AB1E , 21 bytes

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

Pruébelo en línea o verifique los primeros 100 casos de prueba .

Explicación:

Cada número eventualmente resultará en uno 1o 4, por lo que hacemos un bucle indefinidamente y nos detenemos tan pronto como el número esté por debajo de 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)

Ver este consejo 05AB1E mío (sección Cómo usar el diccionario? ) Para entender por qué 'ŽØes "happy".

C ++ 135, 2 líneas

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

Esta es una versión modificada de la que hice aquí:

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

Sí, este desafío tiene tres años; sí, ya tiene una respuesta ganadora; pero como estaba aburrido e hice esto para otro desafío, pensé que podría ponerlo aquí. Sorpresa sorpresa, es larga ... y en ...

Java - 280 264 bytes

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

Sin 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 bytes

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

Para cualquier número dado (como int), h()devolverá el valor correcto. Puede probar el código en .NetFiddle .

Felicitaciones al usuario desconocido para el algoritmo original .

Clojure, 107 97 bytes

Actualización: se eliminó el letenlace innecesario .

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

Primera vez que usa un anidado for: o

R, 117 91 bytes

-16 bytes gracias 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 bytes

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

Pruébalo en línea!

Python 2 , 71 bytes

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

Pruébalo en línea!

... o, para el mismo número de bytes:

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

Pruébalo en línea!

C: 1092 caracteres

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