通过以下过程定义一个满意的数字。从任何正整数开始，用数字的平方和代替数字，然后重复此过程，直到数字等于1（它将停留在该位置），或者它在不包含1的循环中无休止地循环。对于此过程，以1结尾的是快乐数字，而没有以1结尾的过程是不快乐数字（或悲伤数字）。给数字打印是快乐还是不快乐。

Sample Inputs
7
4
13

Sample Outputs
Happy
Unhappy
Happy

注意：对于任何小于1,000,000,000的数字，您的程序所花费的时间不应超过10秒。

Golfscript-34个字符

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

基本相同，这和这些。

这些注释中描述了9次迭代的原因（理论上返回正确的值，直到10^10^10^974（A001273）为止）。

Ruby，77个字符

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

这使用2 ³⁰字节（1GB）数组作为位图来跟踪循环中遇到的数字。在Linux上，只要启用了内存过量使用（通常默认情况下），这实际上可以有效地工作。通过过量使用，可以按需分配阵列的页面并将其清零。

请注意，在Linux上编译该程序会使用1 GB的RAM。

哈斯克尔-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个字符

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

每个快乐的数字收敛到1；每个不开心的数字都收敛到一个包含4的循环。除了利用这一事实之外，这几乎是毫无用处的。

（感谢Ventero，我从他的Ruby解决方案中获得了一个技巧，并节省了6个字符）。

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

称为etex filename.tex 34*23 + 32/2 ?（包括末尾的问号）。表达式中的空格无关紧要。

编辑：我下降到123，但现在输出是dvi（如果使用编译etex）或pdf（如果使用编译pdfetex）。由于TeX是一种排版语言，所以我认为这很公平。

\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个字符

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

从Ventero和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')

通过将a设置为所需的数字来提供输入。

归功于mellamokb。

Python（98，但太混乱了，无法共享）

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

方式，距离竞争太久了，但也许会带来笑声。它在Python中执行“惰性”评估。现在我想到的确实与Haskell条目非常相似，只是没有任何魅力。

dc-47个字符

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

简要描述;简介：

I~：除以10得到的商和余数。
d*：将余数平方。
0<H：如果商大于0，则递归重复。
+：缩小递归堆栈时的值之和。

4<h：当值大于4时，重复平方和位。

Befunge，109岁

返回1 <= n <= 10 ⁹ -1的正确值。

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

J，56

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

动词，而不是独立的脚本，因为问题是模棱两可的。

用法：

   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个字符

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

我敢肯定，胜任的J-er比我能做的还要短。我是一个相对较新的人。

新增和改进：

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

得益于ɐɔıʎuʎ的更新和改进：

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

Python（91个字符）

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

普通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"))))

更具可读性：

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

会更短一些，只从中返回“ Happy”或“ Unhappy” (do)，但是可以说这不会算作整个程序

K，43

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

Jelly，17 个字节（非竞争*）

*语言约会挑战

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

在线尝试！

怎么样？

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字节

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

$ n是输入值

05AB1E，21 字节

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

在线尝试或验证前100个测试用例。

说明：

每个数字最终都会产生1或4，因此我们会无限循环，并在数字小于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)

见我这个05AB1E尖端（部分如何使用字典？）理解为什么'ŽØ是"happy"。

C ++ 135，2行

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

这是我在这里所做的修改后的版本：

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

是的，这个挑战有三年了；是的，它已经有一个赢家的答案；但是由于我很无聊，并且为了另一个挑战而这么做，所以我想把它放在这里。令人惊讶的惊喜，长期以来-在...

爪哇- 280个 264字节

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

取消高尔夫：

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字节

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

对于任何给定的数字（如int），h()将返回正确的值。您可以在.NetFiddle上尝试代码。

对原始算法未知的用户表示敬意。

Clojure，107 97字节

更新：删除了不必要的let绑定。

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

原版的：

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

第一次使用嵌套的for：o

R, 117 91 bytes

-16 bytes thanks to 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字节

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

在线尝试！

Python 2，71个字节

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

在线尝试！

...或者，对于相同的字节数：

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

在线尝试！

C：1092个字符

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