Source code
import java.util.*;
public class SmithNumbers {
public static boolean isPrime(int num) {
if(num==1)
return false;
for(int i=2;i*i<=num;i++) {
if(num%i==0)
return false;
}
return true;
}
public static int digitSum(int num) {
int sum=0;
while(num>0) {
sum+=num%10;
num/=10;
}
return sum;
}
public static int primefactorSum(int num) {
int sum=0;
for(int i=2;i<=num;i++) {
if(isPrime(i) && num%i==0) {
sum+=digitSum(i);
num/=i;
i=1;
}
}
return sum;
}
public static void main(String[] args) {
for(int i=0;i<=10000;i++) {
if(!isPrime(i)&&(digitSum(i)==primefactorSum(i))) {
System.out.println(i);
}
}
}
}
Run 1
The code is moderately readable. It has clear method separation (isPrime, digitSum, primefactorSum) and mostly flat nesting, which helps structure. However, readability suffers in a few areas: the primefactorSum method has a non-obvious reset of the loop counter (i=1) that obscures intent; variable and method names are clear but formatting is inconsistent (e.g., 'primefactorSum' lacks camelCase); action granularity is generally okay, but some lines combine multiple actions. The main method is concise and purpose-driven, but the overall lack of comments or explanatory context reduces clarity. The code is short, but the unusual loop-reset logic makes reasoning about correctness harder, lowering readability.
Run 2
The code is reasonably structured and generally readable, but it has moderate readability issues. The methods are logically organized and concise, with one action per line, which is good. However, the primefactorSum method is somewhat confusing: resetting i to 1 inside the loop is an unusual and non-obvious approach to finding prime factors, and it makes the control flow harder to follow. Variable names like num and i are acceptably clear, but the conditions in the main loop could benefit from whitespace or parentheses for clarity. Nesting is mostly flat, but the primefactorSum loop's logic is not straightforward. Overall, the code is understandable but could be improved with clearer factorization logic or comments.
Run 3
The code is short and somewhat readable, but it has several flaws. Structure is disjointed: primefactorSum 'resets' i to 1 instead of using a loop index, making logic hard to follow. The prime factor summation algorithm is inefficient and the purpose is unclear without domain knowledge. Nesting is acceptable but not flat everywhere. It lacks comments and meaningful variable names; methods avoid helpers like 'isSmith'. The main method does one action per line but the primefactorSum loop has multiple actions tightly coupled. Formatting is inconsistent (brace placement, spacing), reducing readability. Overall the code is comprehensible for an experienced developer but not self-explanatory.
Run 1
Code Structure: Separate methods for primality, digit sums, factor sums, and output provide logical organization. Nesting: Loops and conditionals are shallow and easy to follow. Clarity of intent: Class and method names mostly communicate purpose, but resetting i to 1 while reducing num makes repeated factor extraction less intuitive; primefactorSum also uses inconsistent capitalization. Code length: Compact without substantial unnecessary code, though the wildcard import is unused. Action granularity: Statements generally perform one action per line, with conventional loop headers. Reading flow: Helpers precede main naturally, but tight operator spacing, omitted braces on some conditionals, and modifying the loop counter and bound within primefactorSum interrupt readability. The unexplained upper bound of 10000 and lack of a brief explanation of Smith numbers slightly obscure the overall intent.
Run 2
Code Structure: Well separated into focused methods for primality, digit sums, factor sums, and output. Nesting: Shallow loops and conditionals make the code easy to follow. Clarity of intent: Method names mostly communicate purpose, but primefactorSum has inconsistent naming, and resetting i to 1 while modifying num makes factorization less intuitive. Code length: Compact without excessive boilerplate, although the unused wildcard import adds clutter. Action granularity: Most statements perform one action per line; loop headers conventionally combine initialization, testing, and incrementing. Reading flow: Helpers precede main logically, but cramped operator spacing, omitted braces on some conditionals, and the unexplained 10000 limit reduce readability. The handling of zero in isPrime also obscures the intended domain.
Run 3
Code Structure: Separate methods for primality, digit sums, factor sums, and output provide logical organization. Nesting: Loops and conditionals are shallow and easy to follow. Clarity of intent: Method names largely explain their purpose, but resetting i to 1 during factorization is non-obvious, and the Smith-number condition lacks explanation. Code length: Compact without substantial redundancy, although repeatedly checking primality complicates factorization. Action granularity: Most lines perform one action; loop headers conventionally combine initialization, testing, and incrementing. Reading flow: Methods appear in a natural helper-to-main order, but tight operator spacing, omitted braces on some conditionals, inconsistent method naming, and the unused wildcard import reduce polish. Edge-case behavior for zero and negative inputs also obscures the intended domain.