3077

33
+41  Q:

## Code Golf: Happy Primes!

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
\$ happyprime 440
happy non-prime
\$ happyprime 78
``````

# 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.

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.

+5  A:

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

Nice use of regular expressions as primality check!
You can save 1 character by getting rid of the () for that if statement (leaving a single space behind) as * is already higher precedence than =~.
+4  A:

## 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
\$ echo 440 | python happy.py
happy non-prime
\$ echo 1234567 | python happy.py
``````

--

``````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)])
``````
Couple of minor things I noticed at a brief glance:1: `while True` == `while 1`. 2: Don't need a space after the final print statement. 3: Rename the `ge` function to a single char.
If you use the `match` function (instead of `search`), you don't need the `^` anchor in the regexp.
This is a shorter `p`: `p=lambda n:not re.match(r'1?\$|(11+?)\1+\$','1'*n)`
Since `h` is used only for indexing, it could return `0` and `1` instead of bools.
+9  A:

## C, 188187185184180172171 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(

\$ ./a.out
139
happy prime

\$ ./a.out
2

\$ ./a.out
440
happy non-prime

\$ ./a.out
78
``````

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.

Hmmm, the golfed version seems to give me nothing but segfaults on two machines, the non-golf version works except 1 gives a floating point exception. Ideas? (compiled with `gcc -o hp happyprime.c`)
Golfed version does not compile at all for me (clang 1.0). It tells me that the second argument to main must be `char**`.
fixed. Although with people specifying language versions (or custom golfing-languages) I would rather keep it at 178 and just specify platform and compiler: 32 bit linux using gcc.
As long as I know that it requires a 32-bit compiler that is fine, are there any other `gcc` args I need? I still get an exception with the `1` case from the prime detection routine (initial call is `p(1,0)` leading to a modulo operation with 0 in the divisor).
No other args that I use (although if possible I would opt for a lot of `-D.=...` args). I'll have a look if I can blend in the non-primeness of 1.
+4  A:

## Java: 294286285282277262 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;
}
}
``````
Shouldn't that be `new Char[p]`? Anyway, good job. You beat me
@BalusC, Character Count = 286. :-/
@BalusC, I can save 3 chars. :) I can't seem to `Save my Edit` some proxy error on my side, so i'll post it as a comment. Please Check it and if it's any good update the answer.
import java.util.*;class H{public static void main(String[]a){int n=new Integer(a[0]),p=n,s,d;Set c=new HashSet();for(;n!=1n=s)for(s=0;n>0;d=n%10,s+=d*d,n/=10);System.out.printf("%s %sprime",n==1?"happy":"sad",new String(new char[p]).matches(".?|(..+?)\\1+")?"non-":"");}}
@st0le: the trailing newline shouldn't count. It's really 285. As per your suggestion, yes that's better.
@BalusC, 1 more byte. Move the `Set c=new HashSet()` into the first part of the `for(;c.add(n);)` loop. that saves a semicolon. :) `for(Set c=new HashSet();c.add(n);n=s)`
@BalusC,Haha, Ok, 7 bytes more. Instead of `new String(new char[p])` use `(""+new char[p])`. :D
@st0le: I saved after all 15 chars. Thanks you for the hints :)
@st0le: 2 more chars off, those parentheses are superfluous. Regardless, that gives a false negative for `139`.
Change `Integer` to `Long`, `int` to `long`, save couple more...
also `p=n>1?1:0` can be changed to `p=n`, i think. Since `Behavior would be undefined for input values less than 1` So it ought to do. :D
@BalusC,ignore this comment, just making sure you get notified....:D
@st0le: 1 is valid input. It should become 0 for the case that `while` loop doesn't enter (so that `p>0` in the print is still valid for 1). Changing int to long is a good one, thought of it as well in previous stages, but it didn't work well with new char[n] when the regex was still there, so I didn't use it.
+28  A:

# Mathematica 11510810710210099 91 Chars

Da monkey learnt a few tricks (91 chars)

`````` Print[
If[Nest[[email protected]@([email protected] #^2) &, #, 9] > 1, Sad, Happy ],
If[[email protected]#, " ", " non-"], prime
] &
``````

Invoke with %[7]

### Edit 5 - 99 Chars/

Nine iterations is enough. Thanks @Nabb, @mjschultz

``````h = Print[
If[Nest[Plus @@ ([email protected]#^2) &, #, 9] > 1, "Sad ", "Happy "]
, If[[email protected]#, "", "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 @@ ([email protected]#^2) &, #, 99] > 1, "Sad ", "Happy "]
, If[[email protected]#, "", "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 @@ ([email protected]#^2) &, #, 10^2] > 1, "Sad ", "Happy "]
, If[[email protected]#, "", "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/

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

Explanation:

The

``````    NestWhile[Plus @@ ([email protected]#^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[[email protected]@([email protected]#^2) &, #, #>4 &] /.{1 →"Happy ",_→"Sad "}
, If[[email protected]#, "", "non-"]
, "prime"] &
``````

### Original - 115 Chars/

``````h = Print[
If[NestWhile[Plus @@ ([email protected]#^2) &, #, Unequal, All] == 1
If[[email protected]#, "", "non-"], "prime"] &
``````

The statement

``````NestWhile[Plus @@ ([email protected]#^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]
``````

Looping (Slightly changing the Print statement)

``````1 Happy non-prime
7 Happy prime
10 Happy non-prime
13 Happy prime
``````
Oi, you're going to make me install Mathematica just so I can verify this! (Though I am fully convinced it is correct.)
Why do you use `10^2` instead of `100` or `99`, both of which are shorter?
@Greg yep, tnx ... I started using 10^99 for allowing greater input values and forgot to change that when came down to 85 digits ... Anyway the stack crashed with very big numbers :(
belisarius: I'd bump it all the way down to `9` which puts you at 99 characters total. It still managed to evaluate `2535301200456458802993406410753` in no time on my system.
@mjschultz The required depth is not a monotone function. For example, calculating h[30] requires 11 iterations. The max depth value for numbers under 1000 is 15. So, 9 is way toooo low.
+1, nice explanation!
belisarius: Thanks for doing that, but as a student I have access to Mathematica. However, I'm sure others do not, so it's still useful!
`9` iterations should be sufficient up to `10^974` digits.
@Nabb I guess you've a proof there :). I just followed a few experiments and the Wikipedia statement. Without a proof I didn't want to assume that, and reaching the SAD cycle may take as much as 16 iterations for very small numbers (15999, for example)
@belisarius Your test condition is `>1`, i.e. happy numbers will have reached 1, not unhappy numbers some arbitrary value. The smallest values for n steps: s(5) = 7, s(6) = 356, s(7) = 78999. log₁₀(s(8)) ~ 975 (=78999/81). log₁₀(log₁₀(s(9))) ~ 974. log₁₀(log₁₀(log₁₀(s(10)))) ~ 974. 9 iterations is therefore sufficient for everything up to `10^10^10^974`, or `10^10^974` digits. I suppose I missed a step earlier.
+7  A:

## 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.

Ah, perl my first language. Interesting use of `die` for output, made me fix up my checker script.
Sorry, can be changed if necessary, but it's common practice here if nobody says "absolutely must go to stdout" :)
if you have perl 5.10+, you can also -E and say. also, you can drop \n and just use newline.
+1  A:

## Python 2.6, 300298 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',
if p(x):print'non-prime'
elif not p(x):print'prime'
``````
Close, you'll need to fix it for the `1` case (1 being non-prime). Also you can strip the `[]` in the `sum()`. You could also probably just do `if h(x):` and the like.
Can someone please test this for me. I'm getting a weird problem: if I run this as a .py file from CLI, it says that 1 is prime. If I write the exact same function in an interpreter, it says 1 is not prime...
So I think I fixed the `1` case this time. I'm still confused a bit about the whole logic of it though :P
+64  A:

dc - 107 chars

``````\$ cat happyprimes
\$ echo 1  |dc happyprimes
happy non-prime
\$ echo 139|dc happyprimes
happy prime
\$ echo 2  |dc happyprimes
\$ echo 440|dc happyprimes
happy non-prime
\$ echo 78 |dc happyprimes
``````
Boy, that is nice a cryptic, but it works!
The hell? (15 chars)
What planet is this from?
Code golfing is the third use for dc, the other two are doing modular exponentiation and implementing bc on top of dc (and using bc instead of dc ;P ).
this is hardcore
+12  A:

## C#, 380378374372364363315280275 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)
);
}
}
``````
I was able to cut out quite a bit by doing some obvious golfing, not changing the algorithm at all.
+1 for "figure out happiness"
Added some syntactical updates to save 5 more characters, have a bigger update which removes the need for `p` altogether, will post later.
shaved a character by rewriting the output
+2  A:

## Clojure, 353318298261 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
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
``````

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 "
:else (recur
(reduce +
(for [n (map #(- (int %) 48) (str x))] (* n n)))
(assoc m x 1))))

(println
(str
(h x{})
(if (re-matches #"^1\$|^(11+)?\1+"(apply str(repeat x \1)))
"non-"
"")
"prime")))
``````
Nice, I've never worked with clojure before, but I had to change the `(nth *command-line-args* 1)` to `(nth *command-line-args* 2)`. (1 being your script's name).
Yes that seems to have to do with the bash scripts and the change from the Script class to clojure.main for script support.
+3  A:

## Perl, 135C

``````sub h{my\$s;\$s+=\$_**2for split//,pop;(\$s-4)?(\$s-1)?&h(\$s):1:0}\$a=pop;
``````

Combined C and Perl

It looks like you have "non-prime" and "prime" flip-flopped.
Whoops! Fixed and still 135C.
+2  A:

## 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"")
``````
+1  A:

## Python (285270269246241247240 237 chars, 21202118 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:
break
else:
f=list(str(n))
else:
s='happy '+s
print s
``````

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

using `n=input()` will really cut down on your char count. And it seems to be accepted in the rules.And some things to fix: since you use a `for` loop it appends lots of `non`'s to the `s`. Also, `1` is not prime so you'd need to fix that.
Yes, I realised that as soon as I posted. Edited now.
You don't need the `int()`. `input()` already evaluates the input and makes it an int if it already is one.
I fixed the loop problem and the unnecessary int(). You just have to fix the `1` case.
Oh, I didn't know that. Also managed to cut down one more line by putting the if and statement inside a single line. Also, the lambda was unnecessary, so, one more line and a bunch of characters gone there...
Did your changes get posted? I don't see them here. Oh, and the `int(n)` in your `for` loop is unnecessary because `n` is already an integer. **EDIT:** Nevermind; the changes are here now.
Done :). I don't think it can be shortened any more now without serious mental effort. It's the shortest Python solution here by a long way.
You need that `break` statement in your for loop or else you get this result for 440: `happy nonnonnonnonnonnonnonnonnonnonnonnonnonnonprime`
Yes, just realised that.
Made it even shorter using `while: else:`.
Change `range(2,n/2+1)` to `range(2,n-1)` to save some characters? Who cares about efficiency? Don't you need a `-` after `non`?
Actually, since `xrange(start, stop)` is non-inclusive of the last number, just `xrange(2,n)` will do :)
Rather than `s='non'+s;break` you can use `s='non-prime'` and save a few chars.
@Gabe: but he'd still need the `break` statement in there so it doesn't do the `nonononononononononononprime` problem.
vlad003: The `break` was only necessary because he was concatenating with the previous value. Since `s='non-prime'` is idempotent, there's no need for the `break`.
+9  A:

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

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.

That looks awesome :P. And if you replace your `int(sys.argv[1])` with `input()` it'll bring your char count down to 180.
Thanks! I didn't notice stdin was allowed.
Nice! You beat my solution by 60 chars and 15 lines!
+1, the regex for prime numbers is VERY nice!
@Yassin: Thanks for mentioning that's what it did! I'm just learning programming and I didn't even touch regex yet so I didn't know what it did :-). Now that I look, a lot of the answers use that regex.
@Yassin @vlad003 I just added a link to an explanation of the trick in another SO question.
I just submitted a python answer that uses 169 chars, but it's totally different than this one, so I didn't put it here (i really like the regex trick)
+5  A:

``````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"
``````
You must assume the input is greater than or equal to 1. (1 is a happy non-prime)
Yeah, wasn't sure at first. Fixed now.
The newline is not necessary after the output. so feel free to get take two characters.
+5  A:

# 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"
``````
Nice, I had to add a `}` at the end, but that is probably because I was using Firefox's Web Console. I'm impressed that Javascript and your code was able to handle `h(2535301200456458802993406410753)`!
Leaving the `}` out was a cut and paste mistake. Thanks.
+3  A:

## 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.

A few C golfing tricks which should shave off some: You could try to use the ternary conditional `cond?true:false` which also has useful low precedence properties, comparison for (non-)equality is best done using `a-b` rather than `a!=b`, and looping is shorter with `for` - although `while()` takes as much room as `for(;;)`, the latter gives space to put statements in without the cost of an extra `;`. And there are a few more chars to win still.
@mvds: thanks for the tips.
I know this will cost you a few character, but I get stuck in the last `while` loop when the input is `1`.
@mjschultz: thanks fixed it now. thanks for doing my debugging for me as well. ;)
+2  A:

Scala, 253 247 246 chars

``````object H{def main(a:Array[String]){var s=Set(0)
val n=a(0)toInt
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 :-(

A:

pseudocode 16 char:

No input parms? :)
This does not meet the "source code" requirement.
"Do the dc answer" that sounds like the worst dance move ever...
It seems that every golf contest begets this answer. I wonder if some day somebody will write the REAL code for doing this.
+1  A:

## Python, 169168158157166164 162 chars, 4 lines

``````l=n=input()
while l>4:l=sum(int(i)**2for i in str(l))
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

I do appreciate the non-use of regex, but yours seems to detect `1` as prime and `7` as sad. (Also, strictly speaking the last comma should be a `+`.)
Fixed 'em both!
Hmmm, it still claims that `7` is a "sad prime", instead of "happy prime". Also, you could remove the space before both the `for`s as well.
+3  A:

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
``````
Also, VisualBasic is not a great language for golfing. (English keywords, not free form, etc.)
I do golf challenges without regard to char count just to practice :P
+2  A:

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{(str2num(a)==1)+1},h]
``````

Usage

``````happyprime 139
ans =
Happy prime
``````
+12  A:

## Python - 127 chars

Beating both perl answers at this moment!

``````l=n=input()
while l>4:l=sum(int(i)**2for i in`l`)
``````

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

That is pretty sweet. I wouldn't expect a python answer to be shorter than perl.
The slice trick is cool!
You can use the backticks instead of `str`, as I explain in my answer above.
@Roberto, good catch
I never knew a space isn't required before that first `for`.
+1 Never thought I'd see python beat perl in a terse contest. Incidentally, not gzip, bzip2, or even xz can not compress this smaller than it already is.
@Seth: Most compression algorithms have some small amount of overhead and thus are miserable at compressing tiny files.
+7  A:

## MATLAB 7.8.0 (R2009a) - 120 characters

``````n=input('');
s=n;
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'])
``````
I'm curious about the last line ("disp") ... Could you explain it, please?
@belisarius: `c` is a cell array of strings, and its contents are being indexed by a 1-by-3 logical array with elements `s<2`, `s>1`, and `~isprime(n)`. For every true entry in the index array, the contents of the corresponding cell are dumped into a set of square brackets, which concatenates them into one string along with the word `'prime'`. It is then displayed using `disp`.
Any reason for the `while s>9,` line? It seems to cause invalid output when the input is `7`. Would `while s>6,` work?
@mjschultz: Oops! That was an old typo I had in an earlier version. Fixing...
@mjschultz @gnovice That's why I asked. I thought that the "disp" line made the magic to fix that. Tnx for the explanation!
Clever use of int2str!
+4  A:

# J: 113 characters

``````h=.1=\$:@([:+/[:*:@"."0":)`]@.(e.&1 4)
``````

``````\$ echo -n 7 | jc happy.ijs
happy prime
\$ echo -n 139 | jc happy.ijs
happy prime
\$ echo -n 2 | jc happy.ijs
\$ echo -n 440 | jc happy.ijs
happy non-prime
\$ echo -n 78 | jc happy.ijs
``````
+2  A:

## 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
``````
This does extremely well for everything except for the `1` case.
Oops! Fixed, added 3 characters (total 217 now) to handle the proper prime check for 1.
+2  A:

## Javascript, 192190185182165 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')
``````
This fails in the case where `n=1` where it should say "happy non-prime" instead of "happy prime".
Thanks. I fixed that, making the code even smaller.
+16  A:

# GolfScript - 64 chars (works for 1)

``````~:@.{0\`{15&.*+}/}*1=!"happy sad "6/[email protected],{@\)%!},,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/[email protected],2>{@\%!},!4*"non-prime">
``````
I get...odd behavior when the input is `1`. Is that from a limitation of golfscript or something else? (It says `../lib/golfscript.rb:353:in `select': private method `select' called for nil:NilClass (NoMethodError)`.)
@mjschultz, darn - `1` is a special case in that solution. One char extra for a better primality test
+2  A:

# 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
``````
About time! Now see if you can beat the GolfScript :)
+1  A:

## 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]
``````
+1  A:

# 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/
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/
Ta
x
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/
Ta
p
g
s/^/printf %*s /e
s/^ \$|^(  +)\1+\$/non-/
s/\$/prime/
``````
A:

# Racket, 286 characters

Only issue is that 1 is prime.

``````(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"
))
)
)
``````
+1  A:

## PARI/GP

### 184 bytes

A Bit late to participate, but here's a short one.

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

To use it. Write `f(139)`