Source code
public class SmithNumber {
public static void main(String[] args) {
for(int i = 0; i <= 10000; i++){
if(isSmith(i)){
System.out.println(i);
}
}
}
public static boolean isSmith(int n){
int digitSum = getDigitSum(n);
int factorSum = getFactorSum(n);
return !isPrime(n) && digitSum == factorSum;
}
public static int getDigitSum(int n){
int sum = 0;
while(n > 0){
sum += n % 10;
n /= 10;
}
return sum;
}
public static int getFactorSum(int n){
int sum = 0;
for(int i = 2; i <= n; i++){
while(n % i == 0){
sum += getDigitSum(i);
n /= i;
}
}
return sum;
}
public static boolean isPrime(int n){
if(n <= 1){
return false;
}
for(int i = 2; i <= Math.sqrt(n); i++){
if(n % i == 0){
return false;
}
}
return true;
}
}
Run 1
The code is well-structured into small, focused methods with clear names, making the intent easy to follow. Nesting depth is minimal, with each method handling one specific task. The main loop is simple and readable. Action granularity is good, with one logical step per line. The reading flow is natural—methods are ordered in a logical progression. Minor improvements could include using braces consistently in the for loops, adding comments to explain Smith numbers, and slightly more whitespace between methods, but overall readability is high.
Run 2
The code is reasonably readable. It is well-structured into small methods with clear purposes (isSmith, getDigitSum, getFactorSum, isPrime), which aids comprehension. Nesting is minimal, and action granularity is mostly one action per line. The overall flow is logical: main loop, then helper methods. However, readability is reduced by missing braces on the outer for loop in main and inconsistent formatting (e.g., spacing in `for(int i = 0;`). The use of single-letter variable names (i, n) is acceptable for local loop variables, but `n` in helper methods could be more descriptive (e.g., `number`). The logic in `getFactorSum` is slightly dense due to the nested while inside the for loop, but it remains understandable. Overall, clear structure and intent lift the score above average, but spacing/brace consistency and variable naming prevent a higher rating.
Run 3
The code is well-structured into small, focused methods with descriptive names, making intent clear. The main loop is flat and easy to follow. Nesting is minimal—only one level in a few places. Action granularity is mostly one statement per line, and reading flow is natural from high-level check to helper functions. Minor style issues: inconsistent spacing in for loops (e.g., `for(int i...` vs `for (int...`), and `isPrime` repeatedly calls `Math.sqrt` in the loop condition. `getFactorSum` could be slightly optimized, but overall readability is high due to clean separation of concerns and clear naming.
Run 1
Code Structure: Well-organized methods separate digit summation, factor summation, primality testing, and enumeration. Nesting: Shallow overall, with straightforward two-level nesting in the main and factorization loops. Clarity of intent: Descriptive method names make the purpose clear, although getFactorSum actually sums the digits of prime factors, and modifying n makes its changing role less explicit. Code length: Concise without unnecessary repetition. Action granularity: Each line generally performs one action, making operations easy to follow. Reading flow: The progression from main to supporting methods is natural, though inconsistent spacing slightly reduces polish. The treatment of 0 and 1 in isSmith is a correctness issue rather than primarily a readability issue.
Run 2
Code Structure: Well organized into focused methods for Smith-number detection, digit sums, factor sums, and primality. Nesting: Shallow and easy to follow, with at most two nested control structures. Clarity of intent: Descriptive method names reveal the overall purpose, though getFactorSum could more explicitly indicate summing prime-factor digits, and modifying n requires some attention. Code length: Concise without unnecessary repetition. Action granularity: Each statement performs a single clear action. Reading flow: The entry point and high-level check precede supporting helpers, creating a natural progression. Minor readability weaknesses include inconsistent spacing around control statements and operators, the unexplained upper bound of 10000, and the absence of a brief explanation of Smith numbers.
Run 3
Code Structure: Well organized into small methods separating digit summation, factor summation, primality testing, and output. Nesting: Shallow, with at most two control-flow levels within methods. Clarity of intent: Descriptive method names communicate the purpose, though getFactorSum could more explicitly indicate summing prime-factor digits; accepting 0 and 1 as Smith numbers also obscures the intended definition. Code length: Concise without unnecessary repetition. Action granularity: Statements generally perform one action per line, with conventional loop headers. Reading flow: Natural progression from the entry point to the main predicate and supporting helpers. Consistent indentation helps, but missing spaces around control-flow parentheses and braces slightly reduce polish.