Question

It's Sunday, time for a round of code golf!

Challenge

Write the shortest source code by character count to determine if an input number is a "happy prime", "sad prime", "happy non-prime", or "sad non-prime."

Input

The input should be a integer that comes from a command line argument or stdin. Don't worry about handling big numbers, but do so if you can/want. Behavior would be undefined for input values less than 1, but 1 has a definite result.

Output

Output should print the type of number: "happy prime", "sad prime", "happy non-prime", or "sad non-prime." The trailing newline is optional.

Examples

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

Definitions

Just in case your brain needs a refresher.

Happy Number

From Wikipedia,

A happy number is defined by the following process. Starting with any positive integer, replace the number by the sum of the squares of its digits, and repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle which does not include 1. Those numbers for which this process ends in 1 are happy numbers, while those that do not end in 1 are unhappy numbers (or sad numbers).

For example,

  • 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

Prime Number

A prime number is an integer greater than 1 and has precisely two divisors: 1 and itself.

Happy Prime

A happy prime, is therefore a number that is both happy and prime.

Answer Selection

Obviously the answer will be the shortest source code by character count that outputs the specified results in all cases that I test. I will mark the answer once the next (community decided) code golf challenge comes along, so we can focus all our energies on that one. :)

Decision

Well, it looks like the there is a new code golf in town and it has been about a week since this question was posted, so I've marked the shortest source code as the answer (gnibbler's 64 character Golfscript solution). That said, I enjoyed both the 99 character Mathematica solution by belisarius and the cryptic 107 character dc solution by Nabb.

To all others, great work! I've never had so many programming language environments on my computer. I hope everyone has learned some new, dirty tricks for their favorite language.

Reuse

I've re-published some of the code produced by this competition as an example for a script I wrote to test various programs against a reference implementation for auto-grading. The README in that directory explains where the source code comes from and states that all code is re-used under the CC BY-SA 2.5 license (as stated in SO's legal section). Each directory is labeled with your display name at the time of the submission.

If you have a problem with your code being re-used in this fashion or the attribution, let me know and I will correct the error.

Was it helpful?

Solution

GolfScript - 64 chars (works for 1)

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

This program does n iterations to determine the happiness of the number, which is very wasteful for large numbers, but code-golf is not about conserving resources other than characters. The prime test is similarly inefficient - dividing n by all the values from 1 to n inclusive and checking that there are exactly two values with zero remainder. So while it is theoretically correct, running with really large numbers is not practical on real computers

GolfScript - 63 chars (fails for 1)

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

OTHER TIPS

dc - 98 chars

$ 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

Mathematica 115 108 107 102 100 99 91 87 Chars

87 characters

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

-- Mr.Wizard

Da monkey learnt a few tricks (91 chars)

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

Invoke with %[7]

Edit 5 - 99 Chars/

Nine iterations is enough. Thanks @Nabb, @mjschultz

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

Edit 4 - 100 Chars/

Same as Edit 3, replacing 10^2 by 99 (allowing 84 digits for input values) ... Thanks, @Greg

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

Edit 3 - 102 Chars/

Reworked the loop again.

It is interesting that the recursion depth until eventually reaching 1 is bounded by (15 + Number of digits of the argument). See here

So for numbers with less than 85 digits (I think this limit is pretty well into the OP's "Don't worry about handling big numbers" consideration) the following code works

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

I changed the "NestWhile" for the shorter "Nest", and so, instead of specifying a stop condition for the recursion, is enough to hardcode the desired recursion depth (10^2).

It is not very efficient, but that's the golfer's life :D

Edit 2 - 107 Chars/

Reworked the Sad/Happy assignment

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

All spaces/newlines except on literals are optional and added for readability

Explanation:

The 

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

Recurses applying "function" [Add up sum of digits squared] until the result is 4 or less. The function has the property that it stagnates at "1", or enters the cycle {4, 16, 37, 58, 89, 145, 42, 20, 4, ...}.

So, when the outcome is "1", the number is "Happy" and when the outcome is "4", it is "Sad".

If the result is "2", the number is also SAD, because it'll enter the SAD cycle in the next iteration (2^2 = 4).

If the result is 3, the cycle is 3->9->81->65->61->37->58->89->145-> .... (Enters the SAD loop).

So, we can stop the recursion when the result is 4 or less, knowing that only a result of "1" will lead to a Happy number.

Perhaps other solutions may take advantage of this fact.

In fact, the results 5 and 6 also lead to SAD numbers, but that gives us only an efficiency boost and not a golfing advantage (I guess).

Edit 1 - 108 Chars/

Reworked the Loop Control logic 

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

Original - 115 Chars/

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

The statement 

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

performs the recursive application of the sums of the digits squared, until some value repeats. The "Unequal,All" part takes care of the comparison across the preceding values list. Finally returns the repeated value, which is "1" for Happy Numbers.

Sample run

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

Looping (Slightly changing the Print statement)

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

Python - 127 chars

Beating both perl answers at this moment!

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):]

I also ported this answer to GolfScript and it is just over 1/2 the size!

C#, 380 378 374 372 364 363 315 280 275 274 Chars

By replacing the recursive function with nested loops, I was able to bring the stroke count to a respectable 280 (100 less than the original).

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

Here it is with whitespace:

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

Python 2.6: 194 180 chars, 4 lines

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'

The lexer being able to split 0if and 2for into two tokens each was a nice surprise to me :) (it doesn't work with else though)

Function s (sad) is recursive, and receives the list of previous numbers in the cycle as its second parameter. Primality is tested inline using the regexp trick.

By using the deprecated `n` syntax instead of str(n), one can further reduce the character count by 4 characters, but I choose not to use it.

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

This is one recursive function that never issues a return but either calls itself or prints output when it's done. The recursive function sums squared digits and determines prime-ness in two for loops. The scanf returns 1 which is put as an argument to h(), saving one ; and one 1 (and at the cost of having to use prefix ++p instead of postfix p++ which would make p>C possible instead of p>=C)

r&~5 is 0 for 1 4 5, of which 1 indicates happiness and the others sadness.

Next attempt: drop h() and make main() recursive.

Perl, 140 chars

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"

Linebreaks are optional.

MATLAB 7.8.0 (R2009a) - 120 characters

Whitespace, newlines, and comments added for readability

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'])

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

The above code should work in browsers without additional fancy functions and features (such as Array.prototype.indexOf and [] notation for strings), but I haven't tested it outside of Firefox.

Be aware that all but n are global variables (I'm just being cheap).

Usage

h(139) // returns "happy prime"

Haskell 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

Ruby 1.9

169 168 146 chars

 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"

If we use p instead of $><<, the code is shortened by 2 characters

Usage:

$ ruby happyprime.rb 139 happy prime $ ruby happyprime.rb 2 sad prime

Non golfed:

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

Where the is_prime method is left as an exercise to the reader ;)

J: 113 characters

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

Python 2.6

happy.py: 280 314 333 chars, 14 lines. 

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):]

Usage: 

$ 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

--

Readable version: 

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

Java: 294 286 285 282 277 262 260 chars

  • Update 1: replaced BigInteger#isProbablePrime() by regex. Saved 8 chars.

  • Update 2: replaced && by & (oops). Saved 1 char.

  • Update 3: refactored s a bit. Saved 3 chars.

  • Update 4: the test on n!=1 was superfluous. Saved 5 chars.

  • Update 5: replaced regex by for loop and refactored happy for loops little bits. Saved 15 chars.

  • Update 6: replaced int/Integer by long/Long. Saved 2 chars.

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

With newlines:

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

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

Combined C and Perl

VBA 245 characters

Good starter, will trim if time allows. Its only my 2nd go at code golf!

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

C++, 258 231 230 227 chars

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

not the best golfing language, gave it a good shot anyway. Most of this is straight C so would probably be shorter in C as well.

EDIT

Generally tidied it up, think it's pretty much at the limit now without a complete rerwrite.

Also forgot to add that this assumes that there are no numbers with a sequence with over 0xFFFF numbers which a pretty sensible assumption.

EDIT 2

fixed a bug. rearranged to remove the excessive calls to std::cout.

MATLAB - 166 chars

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]

Usage

happyprime 139
ans =
Happy prime

F#, 249 chars

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

Perl, 113 109 105 chars

Beating all Python answers at this moment! SCNR.

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

Clojure, 353 318 298 261 230 chars

(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

I am leaning on the clojure contrib for the primes sequence. I wonder if using for loops would be shorter than recursion?

I read up on the regex prime number check. It's awesome and removes 30 chars and my dependency on clojure.contrib. I also refactored the command line parsing somwhat and inlined a function.

Pre golf(somewhat outdated):

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

Javascript, 192 190 185 182 165 158 chars

The prime checking runs from 2 to square root of N. I wasted few chars there...

In one line:

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

Formatted:

// 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')

Check: http://jsfiddle.net/TwxAW/6/

PHP 217 Chars

$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";

Usage:

$ 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

Scala, 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"")}}

Probably there is some room for improvements. The damn test for 1 as non-prime costs 6 chars :-(

Python (285 270 269 246 241 247 240 237 chars, 21 20 21 18 19 lines)

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

EDIT: Yes, the number went up, there was a bug :-P

Python 2.6, 300 298 294 chars

Different from previous answer in that this doesn't use regex.

I'm sure there's some way of shortening my h(x) function, but I'm still learning Python so I've got no idea.

p(x) returns True if it's a non-prime. h(x) returns True if it's happy. I've done the t = True so that it shortens the character count when doing the truth check.

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'

Python, 169 168 158 157 166 164 162 chars, 4 lines

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"

Takes a number from stdin and doesn't muck around with regexes like the other python answer, although I must admit that is pretty cool. I could also shave off 6 chars by using backticks instead of the str-function, but let's play nice.

EDIT: Fixed a bug with 1 being a prime, which bumped up the charcount by 10. I figure there must be a more concise way than mine for doing this.

EDIT 2: Apparently, python 2.6 allows print[1, 2] without a space between the two.

EDIT 3: Used another calculation for the happy numbers

Python - 142 chars

I was playing around with this idea, but it turned out too long. Perhaps someone can find a way to make it shorter. Maybe it'll turn out better in Ruby. Should be fun to understand how it works anyway :)

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]

GNU sed, 146 125 chars

Run with sed -rf file. Using -r saves 5 backslashes.

Needs bc, printf, and a shell with support for here-strings.

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 chars (needs neither printf nor here-strings)

Uses the more standard traditional yes and head instead of 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 chars (slightly bad formatted output)

Slightly shorter version, doesn't respect output formatting (has extra spaces and a newline between happy/sad and (non-)prime).

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/
Licensed under: CC-BY-SA with attribution
Not affiliated with StackOverflow
scroll top