Today I was doing what ThoughtWorkers do in their spare time and got puzzled, so I decided to share this with you. If you don't know there's a web site called Programming Praxis that posts little riddles (mostly numeric ones) to be solved in any programming language. I was implementing the solution for Happy Numbers and something strange happened, first let's see my Ruby solution:

``````class Happy

def initialize
@seen = {}
end

def is_happy?(number)
sum = sum_square number
if(@seen.has_key?(1))
initialize
return true
elsif(@seen.has_key?(sum))
initialize
return false
else
@seen[sum] = true
is_happy?(sum)
end
end

private
def sum_square(number)
sum = 0
number.to_s.split(//).each do |d|
sum += d.to_i ** 2
end
return sum
end
end
``````

Probably this is a naive solution (I'm not a Ruby developer) but did the job, tests worked and we are good. After that I've started implement the same solution in Java and here we go (please note the line 31):

``````package com.marcovaltas.happy;

import java.util.HashSet;
import java.util.Set;

public class HappyNumber {
private Set<Integer> seen = new HashSet<Integer>();

private int sumSquare(int number) {
char[] digits = String.valueOf(number).toCharArray();
int sum = 0;
for (char d : digits) {
sum += (int) Math.pow(Double.parseDouble(String.valueOf(d)), 2.0);
}
return sum;
}

public boolean isHappy(int number) {
int sum = sumSquare(number);

if (sum == 1) {
initHash();
return true;
} else if (seen.contains(sum)) {
initHash();
return false;
} else {
isHappy(sum);
}
return false;
}

private void initHash() {
seen = new HashSet<Integer>();
}
}
``````

Line 31 on the Java solution was added because the Java compiler was complaining about the possibility of this method not return, I've even tweeted that. So guess what happened? Didn't work, the tests didn't pass when I was "Uh?!". Can you answer why? Take your time.

I've started to debugging and turns out that my tweet was totally wrong. The Java compiler was right and I needed that `return`, the only thing is that was in the wrong place. Let's see the debugging session, if you want to try it download the code here, you can use Mercurial to download the code.

For the debugging I've used the number 7, and had a break point on line 19. So, as expected, the after the first call `sum` will have the value 49. The algorithm will proceed correctly until `sum` reach 1, then it gets interesting. Now `sum == 1`, so the code enters the `if` clause and reaches the ```return true;``` statement.

``````		int sum = sumSquare(number);

if (sum == 1) {
initHash();
return true;
} else if (seen.contains(sum)) {
initHash();
return false;
} else {
isHappy(sum);
}
return false;
``````

So, what you expect to occur next? Probably, if not aware of what it happening, you will guess that the method returns. No, the call jumps to line 29.

``````		int sum = sumSquare(number);

if (sum == 1) {
initHash();
return true;
} else if (seen.contains(sum)) {
initHash();
return false;
} else {
isHappy(sum);
}
return false;
``````

And then to line 31!

``````		int sum = sumSquare(number);

if (sum == 1) {
initHash();
return true;
} else if (seen.contains(sum)) {
initHash();
return false;
} else {
isHappy(sum);
}
return false;
``````

After that, back to line 29, 31, 29, 31, 29, 31, 29 and finally 31, then returns `false`. So, why this happened? At, first I did some obscure analysis on the Java Language Specification and the book Ruby Programming Language comparing the return statements. But, as all things in life, there was a simpler explanation pointed out by Pavol Bernhauser and Luiz Ribeiro (a fellow TWer) on this blog comments. In fact still is a difference on specification, but a simpler one. For Java the value of returned from a method will be explicit informed by the `return` clause. So, if you follow the execution path here what is happening.

When we reach the first `return true;` (line 23), the control is handled back to `isHappy(sum);` call, the execution proceed to the next `return false;` (line 31), since we were in a recursion the return will handle back to the previous call of `isHappy(sum);` and this repeats through all intermediate numbers that made 7 a happy number (49, 97, 130 and 10). If you run on a debugger you will see the stack piling up.

The correct solution is make the call to `isHappy(sum);` a return call:

``````		int sum = sumSquare(number);

if (sum == 1) {
initHash();
return true;
} else if (seen.contains(sum)) {
initHash();
return false;
} else {
But why the Ruby version worked? Well, as pointed out by Pavol and Luiz, it worked "because Ruby returns the result of last invoked statement as the result of method." in this case the `is_happy?` was the last statement and so will be the result. If I did the same thing I did in Java, putting a `return false;` on the end the Ruby version will not work too. In this case it will follow the same steps that Java took I guess.