Source code
public class HappyNumbers {
public static void main(String[] args) {
for (int i = 1; i <= 1000; i++) {
if (isHappy(i)) {
System.out.println(i);
}
}
}
public static boolean isHappy(int n) {
int sum = 0;
while (n != 1 && n != 4) {
while (n > 0) {
int d = n % 10;
sum += d * d;
n /= 10;
}
n = sum;
sum = 0;
}
return n == 1;
}
}
Run 1
The code is well-structured with a clear separation between the main loop and the happiness-checking logic. The isHappy method uses a concise mathematical approach and avoids unnecessary recursion. Nesting is minimal, with only one inner while loop for digit processing. Variable names are straightforward and intent is clear. Code length is compact without sacrificing readability. Each line performs a single action, contributing to easy scanning. The reading flow is natural, from the main loop to the helper method. Minor improvements could include a comment explaining why '4' is used as a termination condition, but overall the code is highly readable.
Run 2
The code is well-structured and readable. The main loop is clear and the isHappy method is logically separated. Nesting depth is minimal, with only two levels inside isHappy. Intent is clear: find happy numbers between 1 and 1000, though the `n != 4` condition could use a comment to explain its purpose. Code length is concise without being cryptic. Each statement performs one logical action, and reading flow is natural, following the algorithm's order. Minor improvements could include a constant for the unhappy cycle and a brief comment on the algorithm.
Run 3
The code is highly readable. It has a clear structure with a main method iterating up to a defined value and a well-named isHappy helper method. Nesting is minimal and logical. Intent is clear from method and variable names. Code is concise, with action granularity mostly one operation per meaningful step (loop, sum update, digit extraction). The reading flow is natural: digits are squared, summed, and the process repeats until a known terminal state. The only slight readability gap is the use of the 'magic number' 4 as a termination condition without a brief comment, but this is a well-known property of unhappy numbers and does not significantly impact clarity.
Run 1
Code Structure: Clean separation between printing results and checking whether a number is happy. Nesting: Modest, with an if inside a for loop and two nested while loops that fit the algorithm. Clarity of intent: Class and method names clearly convey purpose, though the unexplained cycle-detection constant 4 and abbreviated variables n and d require some familiarity. Code length: Concise without unnecessary logic. Action granularity: Each statement performs one clear operation; conventional for-loop syntax remains easy to read. Reading flow: Consistent formatting and sequential digit processing make execution straightforward to follow. A brief explanation of why reaching 4 terminates the check would improve readability.
Run 2
Code Structure: Clean separation between printing happy numbers and checking them. Nesting: Moderate, with straightforward nested loops and a simple conditional. Clarity of intent: Class and method names convey the purpose, but terse variables and the unexplained cycle-detection constant 4 require familiarity with the algorithm. Code length: Concise without unnecessary statements. Action granularity: Each line performs one clear operation. Reading flow: Natural progression from iteration to digit processing and result checking; resetting sum outside the inner loop slightly increases the effort needed to track state.
Run 3
Code Structure: Clean separation between printing results and checking happiness. Nesting: Modest nesting; the inner digit-processing loop naturally fits within the transformation loop. Clarity of intent: Class and method names convey the purpose, but the unexplained sentinel 4 and abbreviated variable d require some domain knowledge. Code length: Concise without unnecessary boilerplate or repetition. Action granularity: Each statement performs a single clear action on its own line. Reading flow: Execution proceeds naturally from iteration to checking to output, and the happiness calculation is easy to follow. A comment explaining why reaching 4 indicates an unhappy number would improve readability.