49

今天是星期天，是时候进行一轮代码高尔夫了！

挑战

按字符数编写最短的源代码，以确定输入数字是“快乐素数”、“悲伤素数”、“快乐非素数”还是“悲伤非素数”。

输入

输入应该是来自命令行参数或标准输入的整数。不要担心处理大数字，但如果你可以/想要的话就这样做。对于小于 1 的输入值，行为将是未定义的，但 1 具有明确的结果。

输出

输出应该打印数字的类型：“快乐素数”、“悲伤素数”、“快乐非素数”或“悲伤非素数”。尾随换行符是可选的。

例子

$ happyprime 139
happy prime
$ happyprime 2
sad prime
$ happyprime 440
happy non-prime
$ happyprime 78
sad non-prime

定义

以防你的大脑需要复习。

快乐号

来自维基百科，

快乐数由以下过程定义。从任何正整数开始，将数字替换为其数字的平方和，然后重复该过程直到数字等于 1（它将保持不变），或者它在不包括 1 的循环中无限循环。那些数字对于这个过程以 1 结尾的数字是快乐的数字，而那些不以 1 结尾的数字是不快乐的数字（或悲伤的数字）。

例如，

  • 139
  • 1^2 + 3^2 + 9^2 = 91
  • 9^2 + 1^2 = 82
  • 8^2 + 2^2 = 68
  • 6^2 + 8^2 = 100
  • 1^2 + 0^2 + 0^2 = 1

质数

素数是大于 1 的整数，并且正好有两个除数：1 和它自己。

快乐总理

因此，快乐素数是一个既快乐又素数的数。

答案选择

显然，答案将是按字符数计算的最短源代码，它在我测试的所有情况下都输出指定的结果。一旦下一个（社区决定的）代码高尔夫挑战出现，我将标记答案，这样我们就可以将所有精力集中在那个挑战上。:)

决定

好吧，看起来城里有一个新的代码 Golf，自从这个问题发布以来已经过去了大约一周，所以我将最短的源代码标记为答案（gnibbler 的 64 字符Golfscript解决方案）。也就是说，我喜欢belisarius 的99 个字符的Mathematica解决方案和Nabb 的神秘的107 个字符的dc解决方案。

对所有其他人来说，伟大的工作！我的计算机上从未有过如此多的编程语言环境。我希望每个人都为自己喜欢的语言学到了一些新的、肮脏的技巧。

重用

我重新发布了本次比赛产生的一些代码，作为我编写的脚本的示例，该脚本用于针对自动评分的参考实现测试各种程序。该目录中的自述文件解释了源代码的来源，并声明所有代码都在 CC BY-SA 2.5 许可下重复使用（如 SO 的法律部分所述）。每个目录在提交时都标有您的显示名称。

如果您对以这种方式或归属方式重复使用的代码有疑问，请告诉我，我会纠正错误。

4

33 回答 33

67

直流 - 98 个字符

$ cat happyprimes
[happy][sad]?dsI[[I~d*rd0<H+]dsHxd4<h]dshx[r]sr1=rP[ ][ non-]_1lI[1-d2>rdlIr%0<p]dspx-2=rP[prime]p
$ echo 1  |dc happyprimes
happy non-prime
$ echo 139|dc happyprimes
happy prime
$ echo 2  |dc happyprimes
sad prime
$ echo 440|dc happyprimes
happy non-prime
$ echo 78 |dc happyprimes
sad non-prime
于 2010-08-23T01:45:21.870 回答
29

Mathematica 115 108 107 102 100 99 91 87 个字符

87 个字符

Print[If[Nest[Tr[IntegerDigits@#^2]&,#,9]>1,Sad,Happy],If[PrimeQ@#," "," non-"],prime]&

——巫师先生

大猴学了几招（91个字符）

 Print[
       If[Nest[Plus@@(IntegerDigits@ #^2) &, #, 9] > 1, Sad, Happy ],
       If[PrimeQ@#, " ", " non-"], prime
      ] &

使用 %[7] 调用

编辑 5 - 99 个字符/

九次迭代就足够了。谢谢@Nabb，@mjschultz

h = Print[
    If[Nest[Plus @@ (IntegerDigits@#^2) &, #, 9] > 1, "Sad ", "Happy "]
   , If[PrimeQ@#, "", "non-"], "prime"] &

编辑 4 - 100 个字符/

与编辑 3 相同，将 10^2 替换为 99（允许 84 位输入值）...谢谢，@Greg

h = Print[
    If[Nest[Plus @@ (IntegerDigits@#^2) &, #, 99] > 1, "Sad ", "Happy "]
   , If[PrimeQ@#, "", "non-"], "prime"] &

编辑 3 - 102 个字符/

再次重做循环。

有趣的是，直到最终达到 1 的递归深度受 (15 + 参数的位数) 的限制。看这里

因此，对于少于 85 位的数字（我认为这个限制非常符合 OP 的“不要担心处理大数字”的考虑）以下代码有效

h = Print[
    If[Nest[Plus @@ (IntegerDigits@#^2) &, #, 10^2] > 1, "Sad ", "Happy "]
   , If[PrimeQ@#, "", "non-"], "prime"] &

我将“NestWhile”更改为较短的“Nest”，因此，无需为递归指定停止条件，而是足以硬编码所需的递归深度 (10^2)。

它效率不高，但这就是高尔夫球手的生活：D

编辑 2 - 107 个字符/

重做悲伤/快乐的任务

h = Print[
     If[NestWhile[Plus @@ (IntegerDigits@#^2) &, #, # > 4 &] > 1,"Sad ","Happy "]
    ,If[PrimeQ@#, "", "non-"]
    , "prime"] &

除文字外的所有空格/换行符都是可选的，并添加以提高可读性

解释：

这 

    NestWhile[Plus @@ (IntegerDigits@#^2) &, #, # > 4 &]

递归应用“函数”[将数字平方和相加]，直到结果为 4 或更少。该函数具有在“1”处停滞或进入循环{4,16,37,58,89,145,42,20,4,...}的性质。

因此，当结果为“1”时，数字为“快乐”，当结果为“4”时，数字为“悲伤”。

如果结果为“2”，则该数字也是 SAD，因为它将在下一次迭代中进入 SAD 循环（2^2 = 4）。

如果结果为 3，则循环为 3->9->81->65->61->37->58->89->145-> ....（进入 SAD 循环）。

因此，我们可以在结果为 4 或更少时停止递归，因为知道只有“1”的结果才会导致 Happy 数。

也许其他解决方案可能会利用这一事实。

事实上，结果 5 和 6 也导致了 SAD 数字，但这只会提高我们的效率，而不是打高尔夫球的优势（我猜）。

编辑 1 - 108 个字符/

重做循环控制逻辑 

    h = Print[
        NestWhile[Plus@@(IntegerDigits@#^2) &, #, #>4 &] /.{1 →"Happy ",_→"Sad "}
          , If[PrimeQ@#, "", "non-"]
          , "prime"] &

原始 - 115 个字符/

h = Print[
    If[NestWhile[Plus @@ (IntegerDigits@#^2) &, #, Unequal, All] == 1
        ,"Happy ", "Sad "],      
    If[PrimeQ@#, "", "non-"], "prime"] &

该声明 

NestWhile[Plus @@ (IntegerDigits@#^2) &, #, Unequal, All]

执行数字平方和的递归应用，直到某个值重复。"Unequal,All" 部分负责对前面的值列表进行比较。最后返回重复值，即快乐数字的“1”。

样品运行

h[7]
Happy prime
h[2535301200456458802993406410753]
Sad non-prime

循环（稍微改变打印语句）

1 Happy non-prime
2 Sad prime
3 Sad prime
4 Sad non-prime
5 Sad prime
6 Sad non-prime
7 Happy prime
8 Sad non-prime
9 Sad non-prime
10 Happy non-prime
11 Sad prime
12 Sad non-prime
13 Happy prime
于 2010-08-23T01:18:05.403 回答
19

GolfScript - 64 个字符（适用于 1）

~:@.{0\`{15&.*+}/}*1=!"happy sad "6/=@,{@\)%!},,2=4*"non-prime">

这个程序通过n迭代来确定数字的幸福度，这对于大数字来说是非常浪费的，但是 code-golf 并不是为了节省字符以外的资源。素数测试同样效率低下 - 除以n所有值从1到n包括在内，并检查是否正好有两个余数为零的值。所以虽然理论上是正确的，但在真正的计算机上运行非常大的数字是不切实际的

GolfScript - 63 个字符（1 个失败）

~:@9{0\`{15&.*+}/}*1=!"happy sad "6/=@,2>{@\%!},!4*"non-prime">
于 2010-08-24T13:22:26.677 回答
13

Python - 127 个字符

此刻击败了两个 perl 答案！

l=n=input()
while l>4:l=sum(int(i)**2for i in`l`)
print['sad','happy'][l<2],'non-prime'[4*all(n%i for i in range(2,n))*(n>1):]

我还将这个答案移植到GolfScript，它的大小只有 1/2 多一点！

于 2010-08-23T18:13:59.680 回答
12

C#，380 378 374 372 364 363 315 280 275 274个字符

通过用嵌套循环替换递归函数，我能够将笔画数提高到可观的 280 次（比原来的少 100 次）。

class P{static void Main(string[]a){var s=new System.Collections.Generic.HashSet<int>();int n=int.Parse(a[0]),p=n>1?4:0,c,d=1;for(;++d<n;)if(n%d<1)p=0;for(;n>1&s.Add(n);n=c)for(c=0;n>0;c+=d*d,n/=10)d=n%10;System.Console.Write((n>1?"sad":"happy")+" non-prime".Remove(1,p));}}

这里是空格：

class P
{
    static void Main(string[] a)
    {
        var s = new System.Collections.Generic.HashSet<int>();
        int n = int.Parse(a[0]),
            p = n > 1 ? 4 : 0,
            c,
            d = 1;
        // find out if the number is prime
        while (++d < n)
            if (n % d < 1)
                p = 0;
        // figure out happiness
        for (; n > 1 & s.Add(n); n = c)
            for (c = 0; n > 0; c += d * d, n /= 10)
                d = n % 10;

        System.Console.Write(
            (n > 1 ? "sad" : "happy")
            + " non-prime".Remove(1,p)
            );
    }
}
于 2010-08-23T01:47:12.323 回答
9

C、188 187 185 184 180 172 171 165

h(c,C,r,p){for(;C>1&&C%++p;);for(;c;c/=10)r+=c%10*(c%10);r&~5?h(r,C,0,1):printf(
"%s %sprime",r-1?"sad":"happy",p>=C&C>1?"":"non-");}main(c){h(c,c,0,scanf("%d",&c));}

$ ./a.out
139
happy prime

$ ./a.out
2
sad prime

$ ./a.out
440
happy non-prime

$ ./a.out
78
sad non-prime

这是一个从不发出 a 的递归函数，它return要么调用自身，要么在完成时打印输出。递归函数对数字平方求和并确定两个 for 循环中的素数。scanf 返回1它作为参数放入h()，保存一个;和一个1（并且必须使用前缀++p而不是后缀p++，这p>C可以代替p>=C）

r&~5是0for 1 4 5，其中1表示快乐，其他表示悲伤。

下一次尝试：droph()并进行main()递归。

于 2010-08-23T00:16:35.437 回答
9

Python 2.6：194 180 个字符，4 行

import re
s=lambda n,l:0if n==1 else n in l or s(sum(int(a)**2for a in str(n)),l+[n])
n=input()
print['happy','sad'][s(n,[])],'non-'*bool(re.match(r'1?$|(11+?)\1+$','1'*n))+'prime'

词法分析器能够将每个标记分成两个标记0if，2for这对我来说是一个惊喜:)（虽然它不起作用else）

函数s(sad) 是递归的，它接收循环中先前数字的列表作为其第二个参数。Primality 使用regexp 技巧进行内联测试。

通过使用不推荐使用的`n`语法而不是str(n)，可以将字符数进一步减少 4 个字符，但我选择不使用它。

于 2010-08-23T02:52:31.583 回答
8

Perl，140 个字符

sub h{$_==1&& happy||$s{$_}++&& sad
||do{$m=0;$m+=$_**2for split//;$_=$m;&h}}$n=$_=pop;
die h,$",(1x$n)=~/^1?$|^(11+?)\1+$/&&"non-","prime\n"

换行符是可选的。

于 2010-08-23T01:23:20.520 回答
7

MATLAB 7.8.0 (R2009a) - 120 个字符

添加空格、换行符和注释以提高可读性

n=input('');
s=n;
c={'happy ','sad ','non-'};
while s>6,
  s=int2str(s)-48;
  s=s*s';                    %'# Comment to fix code highlighting
end;
disp([c{[s<2 s>1 ~isprime(n)]} 'prime'])
于 2010-08-23T19:06:56.083 回答
5

红宝石 1.9

169 168 146 个字符

 h={1=>'happy'};s=->x{y=0;(y+=(x%10)**2;x/=10)while x>0;h[y]||(h[y]='sad';s[y])}
 $><<s[n=$*[0].to_i]+" #{'non-'if '1'*n=~/^1?$|^(11+?)\1+$/}prime"

如果我们使用p而不是$><<，代码将缩短 2 个字符

用法：

$ ruby​​ happyprime.rb 139 快乐素数 $ ruby​​ happyprime.rb 2 悲伤素数

非打高尔夫球：

hash = {1->'happy'}
is_happy = lambda do |number|
  #sum = number.scan(/\d/).reduce(0){|acum, digit| acum + digit.to_i ** 2 }
  sum=0; 
  while (number > 0)
      sum+= (number%10)**2
      number/=10
  end
  return hash[sum] if hash[sum] # If 1, or if cycled and hash contains the number already
  h[sum] = 'sad'
  return is_happy.call(sum)
end
number = ARGV[0].to_i
string = ""
string += is_happy.call(number) # either 'happy' or 'sad'
string += is_prime(number) ? " non-prime" : "prime"
puts string

该is_prime方法留给读者作为练习；）

于 2010-08-22T23:43:57.750 回答
5

哈斯克尔 172

h s n|n`notElem`s=h(n:s)$sum[read[k]^2|k<-show n]|1`elem`s="happy "|0<1="sad "
c n|n<2||any((0==).mod n)[2..n-1]="non-"|0<1=[]
y n=h[]n++c n++"prime"
main=readLn>>=putStr.y
于 2010-08-23T03:30:10.917 回答
5

Javascript 244 250

function h(n){p=n=n<2?10:n;a=",";w="";s=[];while((y=a+s.join(a)+a).indexOf(a+n+a)<0){s.push(n);k=""+n;n=0;for(i=0;i<k.length;)c=k.charAt(i++),n+=c*c}w+=y.indexOf(",1,")<0?"sad ":"happy ";for(i=2;i<p;)p=p%i++?p:0;w+=p?"":"non-";return w+"prime"}

上面的代码应该可以在没有额外花哨功能和特性（例如字符串Array.prototype.indexOf和[]符号）的浏览器中工作，但我没有在 Firefox 之外对其进行测试。

请注意，所有n变量都是全局变量（我只是很便宜）。

用法

h(139) // returns "happy prime"
于 2010-08-23T04:52:12.077 回答
4

蟒蛇2.6

happy.py：280 314 333个字符，14 行。

import re
def q(z):
 while z!=1:z=sum((int(a)**2 for a in `z`));yield z
def h(g):
 l=[]
 while 1:
  try:z=g.next()
  except:return 'happy '
  if z in l:return 'sad '
  l.append(z)
p=lambda n:not re.match(r'^1$|^(11+?)\1+$','1'*n)
n=int(input())
print h(q(n))+'non-prime'[4*p(n):]

用法：

$ echo 139 | python happy.py
happy prime
$ echo 2 | python happy.py
sad prime
$ echo 440 | python happy.py
happy non-prime
$ echo 1234567 | python happy.py
sad non-prime

--

可读版本：

import re, sys

def happy_generator(z):
    while z != 1:
        z = sum((int(a)**2 for a in str(z)))
        yield z

def is_happy(number):
    last = []
    hg = happy_generator(number)
    while True:
        try:
            z = hg.next()
        except StopIteration:
            return True

        if z in last:
            return False
        last.append(z)

def is_prime(number):
    """Prime test using regular expressions :)"""
    return re.match(r'^1?$|^(11+?)\1+$', '1'*number) is None

n = int(sys.argv[1])

print "%s %sprime" % (('sad','happy')[is_happy(n)], ('non-','')[is_prime(n)])
于 2010-08-23T00:13:23.167 回答
4

Java：294 286 285 282 277 262 260 个字符

  • 更新 1：替换BigInteger#isProbablePrime()为正则表达式。节省了 8 个字符。

  • 更新 2：替换&&为&(oops)。节省了 1 个字符。

  • 更新 3：重构s了一下。节省了 3 个字符。

  • 更新 4：测试n!=1是多余的。节省了 5 个字符。

  • 更新 5：用 for 循环替换正则表达式并重构快乐 for 循环一点点。节省了 15 个字符。

  • 更新 6：替换int/Integer为long/Long. 保存了 2 个字符。

import java.util.*;class H{public static void main(String[]a){long n=new Long(a[0]),p=n>1?1:0,s,d=1;while(++d<n)if(n%d<1)p=0;for(Set c=new HashSet();c.add(n);n=s)for(s=0;n>0;s+=d*d,n/=10)d=n%10;System.out.printf("%s %sprime",n>1?"sad":"happy",p>0?"":"non-");}}

使用换行符：

import java.util.*;
class H{
 public static void main(String[]a){
  long n=new Long(a[0]),p=n>1?1:0,s,d=1;
  while(++d<n)if(n%d<1)p=0;
  for(Set c=new HashSet();c.add(n);n=s)for(s=0;n>0;s+=d*d,n/=10)d=n%10;
  System.out.printf("%s %sprime",n>1?"sad":"happy",p>0?"":"non-");
 }
}
于 2010-08-23T00:57:18.803 回答
4

J：113 个字符

h=.1=$:@([:+/[:*:@"."0":)`]@.(e.&1 4)
1!:2&2;(({&('sad ';'happy '))@h,({&('non-prime';'prime'))@(1&p:))".(1!:1]3)

 

$ echo -n 7 | jc happy.ijs
happy prime
$ echo -n 139 | jc happy.ijs
happy prime
$ echo -n 2 | jc happy.ijs
sad prime
$ echo -n 440 | jc happy.ijs
happy non-prime
$ echo -n 78 | jc happy.ijs
sad non-prime
于 2010-08-23T22:03:11.907 回答
3

Perl, 135C

sub h{my$s;$s+=$_**2for split//,pop;($s-4)?($s-1)?&h($s):1:0}$a=pop;
print h($a)?happy:sad,$",(1x$a)=~/^1?$|^(11+?)\1+$/&&"non-",prime

结合C和Perl

于 2010-08-23T02:01:06.310 回答
3

C++，258 231 230 227 个字符

#include<iostream>
#define w while
int m,n,i,j,t=10;int main(){w(std::cin>>n){j=0,m=n;w(n>1){i=0;do i+=n%t*(n%t);w(n/=t);n=n*n+i;n=++j&0xFFFF?n:0;}i=1;w(m%++i&&j>1);std::cout<<(n?"happy":"sad")<<(i-m?" non-":" ")<<"prime\n";}}

不是最好的高尔夫语言，反正打得很好。其中大部分是直接的 C，因此在 C 中也可能更短。

编辑

一般都整理好了，觉得现在已经差不多到极限了，没有完全重写。

还忘了补充一点，这是假设没有数字序列超过 0xFFFF 的数字，这是一个非常明智的假设。

编辑 2

修复了一个错误。重新安排以删除对 std::cout 的过多调用。

于 2010-08-23T06:01:35.497 回答
3

VBA 245 个字符

好的开胃菜，如果时间允许，会修剪。这是我第二次参加代码高尔夫！

Public Sub G(N)
Dim Z, D, X, O
X = N
Z = N
Do Until Z = 1 Or X > N Or X = 0
    X = 0
    For D = 1 To Len(CStr(Z))
        X = X + CLng(Mid(CStr(Z), D, 1) ^ 2)
    Next D
    Z = X
Loop
If Z = 1 Then O = "Happy" Else O = "Sad"
D = 2
Do
    If N / D = Int(N / D) Then O = O & " Not Prime": Debug.Print O: Exit Sub
    D = D + 1
Loop While D < N
O = O & " Prime"
Debug.Print O
End Sub
于 2010-08-23T14:43:45.187 回答
3

MATLAB - 166 个字符

function happyprime(a)
h={'non-prime','prime'};
h=h{isprime(str2num(a))+1};
for i=1:99
   a=num2str(sum(str2num((a)').^2));
end
s={'Sad ','Happy '};
[s{(str2num(a)==1)+1},h]

用法

happyprime 139
ans =
Happy prime
于 2010-08-23T17:35:49.517 回答
2

Clojure，353 318 298 261 230 个字符

(defn h[x m](cond(= x 1)"happy "(m x)"sad ":else(recur(reduce +(for[n(map #(-(int %)48)(str x))](* n n)))(assoc m x 1))))(println(let [x (read)](str(h x{})(if(re-matches #"^1$|^(11+)?\1+"(apply str(repeat x\1)))"non-""")"prime")))

ptimac:clojure pti$ clj  happy.clj 139
CP=/Users/pti/playpen/clojure:/Users/pti/Library/Clojure/lib/clojure.jar:/Users/pti/Library/Clojure/lib/jline.jar:/Users/pti/Library/Clojure/lib/clojure-contrib.jar
happy prime
ptimac:clojure pti$ clj  happy.clj 440
CP=/Users/pti/playpen/clojure:/Users/pti/Library/Clojure/lib/clojure.jar:/Users/pti/Library/Clojure/lib/jline.jar:/Users/pti/Library/Clojure/lib/clojure-contrib.jar
happy non-prime
ptimac:clojure pti$ clj  happy.clj 2
CP=/Users/pti/playpen/clojure:/Users/pti/Library/Clojure/lib/clojure.jar:/Users/pti/Library/Clojure/lib/jline.jar:/Users/pti/Library/Clojure/lib/clojure-contrib.jar
sad prime
ptimac:clojure pti$ clj  happy.clj 78
CP=/Users/pti/playpen/clojure:/Users/pti/Library/Clojure/lib/clojure.jar:/Users/pti/Library/Clojure/lib/jline.jar:/Users/pti/Library/Clojure/lib/clojure-contrib.jar
sad non-prime

我依靠素数序列的clojure contrib。我想知道使用 for 循环是否会比递归更短？

我阅读了正则表达式素数检查。它很棒，它删除了 30 个字符和我对 clojure.contrib 的依赖。我还重构了命令行解析 somwhat 并内联了一个函数。

高尔夫前（有点过时）：

(defn h[x m]
  (cond
   (= x 1) "happy "
   (m x) "sad "
   :else (recur
               (reduce +
                 (for [n (map #(- (int %) 48) (str x))] (* n n))) 
               (assoc m x 1))))

    (println
      (let [x (read)]
        (str
           (h x{})
           (if (re-matches #"^1$|^(11+)?\1+"(apply str(repeat x \1)))
             "non-"
             "")
           "prime")))
于 2010-08-23T01:56:27.770 回答
2

F#，249 个字符

let n=stdin.ReadLine()|>int
let rec s x=seq{yield x;yield!string x|>Seq.sumBy(fun c->(int c-48)*(int c-48))|>s}
printfn"%s %sprime"(if s n|>Seq.take 99|>Seq.exists((=)1)then"happy"else"sad")(if[2..n/2]|>Seq.exists(fun d->n%d=0)then"non-"else"")
于 2010-08-23T02:26:45.830 回答
2

斯卡拉，253 247 246

object H{def main(a:Array[String]){var s=Set(0)
val n=a(0)toInt
def r(m:Int):String={val k=""+m map(c=>c*(c-96)+2304)sum;if(k<2)"happy"else if(s(k))"sad"else{s+=k;r(k)}}
printf("%s %sprime",r(n),if(n<2|(2 to n-1 exists(n%_==0)))"non-"else"")}}

可能还有一些改进的余地。1 作为非素数的该死测试需要 6 个字符 :-(

于 2010-08-23T07:37:47.663 回答
2

PHP 217 个字符

$t=$argv[1];for($z=$t-1,$p=1;$z&&++$p<$t;)$z=$t%$p;$f=array(1);while(!in_array($t,$f,1)){$f[]=$t;$t=array_reduce(str_split($t),function($v,$c){return $v+=$c*$c;});}print($t<2?"happy ":"sad ").(!$z?"non-":"")."prime";

用法：

$ php -r '$t=$argv[1];for($z=$t-1,$p=1;$z&&++$p<$t;)$z=$t%$p;$f=array(1);while(!in_array($t,$f,1)){$f[]=$t;$t=array_reduce(str_split($t),function($v,$c){return $v+=$c*$c;});}print($t<2?"happy ":"sad ").(!$z?"non-":"")."prime";' 139
happy prime
于 2010-08-24T00:25:11.147 回答
2

Javascript，192 190 185 182 165 158 个字符

素数检查从2到 的平方根N。我在那里浪费了几个字符......

在一行中：

for(x=2,y=m=n=prompt();x*x<y&&n%x++;);for(s={};!s[m];m=p)for(s[m]=1,p=0;m;m=(m-=k=m%10)/10,p+=k*k);alert((m-1?'sad':'happy')+(n-1&&x*x>y?' ':' non-')+'prime')

格式化：

// Getting the number from the input and checking for primeness
// (ie. if after the loop x>y => n is prime)
for (x=2, y=m=n=prompt(); x*x<y && n%x++;)

// Checking for happiness
// the loop is broken out of if m is already encountered
// the m==1 after the loop indicates happy number
for(s={}; !s[m]; m=p)
    for (s[m]=1, p=0; m; m=(m -= k=m%10)/10, p+=k * k);

alert((m-1 ? 'sad' : 'happy') + (n-1 && x*x>y ? ' ' : ' non-') + 'prime')

检查：http: //jsfiddle.net/TwxAW/6/

于 2010-08-24T12:02:54.317 回答
2

Perl，113 109 105 个字符

此刻击败所有 Python 答案！信噪比。

$n=$s=<>;$s=0,s/\d/$s+=$&*$&/ge while($_=$s)>4;die$s>1?sad:happy,$","non-"x(1x$n)=~/^1$|(^11+)\1+$/,prime
于 2010-08-24T19:11:39.620 回答
1

蟒蛇2.6，300 298294 个字符

与以前的答案不同，这不使用正则表达式。

我确信有一些方法可以缩短我的h(x)函数，但我还在学习 Python，所以我不知道。

p(x)如果它是非素数，则返回 True。h(x)如果高兴，则返回 True。我已经这样做了，t = True以便在进行真相检查时缩短字符数。

x=input()
def p(x):
 if x==1 or 1 in [1 for i in range(2,x) if x%i==0]: return True
def h(x):
 l=[]
 while x not in l:
  l.append(x)
  x=sum([int(i)**2 for i in str(x)])
 if 1 in l: return True
if h(x):print'happy',
elif not h(x):print'sad',
if p(x):print'non-prime'
elif not p(x):print'prime'
于 2010-08-23T01:36:22.457 回答
1

Python （285 270 269 246 241 247 240237 个字符，21 20 21 1819 行）

n=input()
s='prime'
for i in range(2,n):
    if n%i==0: 
        s='non'+s
        break
f=list(str(n))
g=set()
while n!=1:
    n=sum([int(z)**2 for z in f])
    if n in g:
        s='sad '+s
        break
    else:
        f=list(str(n))
        g.add(n)
else:
    s='happy '+s
print s

编辑：是的，数字上升了，有一个错误:-P

于 2010-08-23T02:34:09.127 回答
1

Python，169 168 158 157 166 164 162 个字符，4 行

l=n=input()
while l>4:l=sum(int(i)**2for i in str(l))
print['sad','happy'][l==1and str(n)!=1],
print['non-',''][n!=1 and sum(n%i==0for i in range(1,n))<2]+"prime"

从标准输入中获取一个数字，并且不会像其他 python 答案那样使用正则表达式，尽管我必须承认这很酷。我也可以通过使用反引号而不是 str 函数来减少 6 个字符，但让我们玩得好。

编辑：修复了一个以 1 为素数的错误，该错误将字符数增加了 10。我认为必须有比我更简洁的方法来执行此操作。

编辑 2：显然，python 2.6 允许print[1, 2]两者之间没有空格。

编辑 3：对快乐数字使用了另一种计算方法

于 2010-08-23T14:08:04.293 回答
1

Python - 142 个字符

我一直在玩这个想法，但结果太长了。也许有人可以找到一种方法来缩短它。也许它会在 Ruby 中变得更好。无论如何理解它是如何工作的应该很有趣:)

n=input();L=[n];print"%s non-prime"[4*([1for f in range(1,n)if L.append(sum(int(x)**2for x in`L[-1]`))or n%f<1]==[1]):]%['sad','happy'][1in L]
于 2010-08-25T01:30:46.670 回答
1

GNU sed，146 125 个字符

使用 sed -rf 文件运行。使用 -r 可以节省 5 个反斜杠。

需要bc, printf, 和一个支持 here-strings 的 shell。

h
s/^/printf %*s /e
s/^ $|^(  +)\1+$/non-/
s/ *$/prime/
x
:a
s/./+&*&/g
s//bc<<</e
tb
:b
s/^1$/happy/
s/^4$/sad/
Ta
G
s/\n/ /

GNU sed，155 141 个字符（既不需要 printf 也不需要 here-strings）

使用更标准的传统yes和head而不是printf.

h
:a
s/./+&*&/g
s/.*/echo 0&|bc/e
tb
:b
s/^1$/happy/
s/^4$/sad/
Ta
x
s/^/yes|head -/e
s/\n//g
s/^y$|^(yy+)\1+$/non-/
s/y*$/prime/
x
G
s/\n/ /

GNU sed，134 115 个字符（格式输出稍差）

稍短的版本，不尊重输出格式（在快乐/悲伤和（非）素数之间有额外的空格和换行符）。

h
:a
s/./+&*&/g
s//bc<<</e
tb
:b
s/^1$/happy/
s/^4$/sad/
Ta
p
g
s/^/printf %*s /e
s/^ $|^(  +)\1+$/non-/
s/$/prime/
于 2010-08-25T17:40:58.407 回答
1

巴黎/全科医生

184 字节

参加有点晚了，但这里有一个简短的。

a(x,v=[])=s=0;while(x,s+=(x%10)^2;x\=10);for(k=1,length(v),if(v[k]==s,return("sad ")));return(if(s==1,"happy ",v=concat(v,s);a(s,v)));f(x)=print(a(x),if(!isprime(x),"non-",""),"prime")

使用它。写f(139)

于 2010-10-18T12:51:43.493 回答
0

球拍，286 个字符

唯一的问题是 1 是素数。

(define d
  (lambda (n)
    (cond
      ((= n 0) 0)
      ((+
       (expt (modulo n 10) 2)
       (d (floor (/ n 10)))
       ))
      )
    )
  )

(define dd
  (lambda (n l)
    (cond
      ((= n 1) "happy ")
      ((for/or ([v l]) (= n v)) "sad ")
      ((dd (d n) (cons n l)))
      )
    )
  )

(define cg
  (lambda (n)
    (display (dd n '()))
    (display
    (if
     (for/and
       ([i (in-range 2 (floor (+ (sqrt n) 1)))]) (> (modulo n i) 0))
       "prime" "non-prime"
     ))
    )
  )
于 2010-09-18T21:16:10.693 回答
0

JavaScript - 171（闭包编译器压缩）

刚刚发现这个有趣的挑战。这是 JavaScript 中的 171 个字符：

function h(a){for(b=2,c="";b<a;b++)a%b||(c="non-");c+="prime";for(b={};;){if(a==1)return"happy "+c;if(b[a])return"sad "+c;b[a]=1;for(e=0;a;){d=a%10;e+=d*d;a=(a-d)/10}a=e}}

我在高级模式下通过Closure Compiler运行源代码来压缩它。来源：

function h(num)
{
    // Check for prime-ness
    // Save the word "prime" by attaching a "non-" in front if it has a factor
    // Notice that we are not concerned with performance here, otherwise should
    // break when a factor is found and should only go up to Math.sqrt(num)

    for (var x=2, prime=""; x < num; x++) {
        if (!(num % x)) prime="non-";
    }

    // Create "prime" or "non-prime"

    prime += "prime";

    // Keep all visited numbers in a hash

    var visited = {};

    while(true) {
        // If the number is one, then happy
        if (num == 1) return "happy " + prime;

        // Otherwise put it into the hash
        if (visited[num]) return "sad " + prime;
        visited[num] = 1;

        // Recalculate the new number by shifting through each digit
        var sum = 0;
        while (num) {   // Stop when num -> 0 (i.e. no more digits)
            var digit = num % 10;
            sum += digit * digit;
            num = (num - digit)/10; // Shift by one digit
        }

        num = sum;
    }
}
于 2011-04-26T08:36:03.570 回答