Source code
public class SmithNumber {
public static void main(String[] args) {
for (int i = 1; i <= 10000; i++) {
if (isSmithNumber(i)) {
System.out.println(i);
}
}
}
private static boolean isSmithNumber(int number) {
int digitSum = digitSum(number);
int factorSum = factorSum(number);
return digitSum == factorSum && !isPrime(number);
}
private static int digitSum(int number) {
int sum = 0;
while (number > 0) {
sum += number % 10;
number /= 10;
}
return sum;
}
private static int factorSum(int number) {
int sum = 0;
for (int i = 2; i <= number; i++) {
while (number % i == 0) {
sum += digitSum(i);
number /= i;
}
}
return sum;
}
private static boolean isPrime(int number) {
if (number < 2) {
return false;
}
for (int i = 2; i <= Math.sqrt(number); i++) {
if (number % i == 0) {
return false;
}
}
return true;
}
}
Run 1
The code is logically organized into small, focused methods with clear names, making the flow easy to follow: main loop, Smith number check, digit sum, prime factor sum, and primality test. Nesting is minimal—only one level inside loops and conditionals. Intent is transparent; each method does exactly what its name suggests. Code length is compact without sacrificing clarity. Action granularity is mostly one action per line, improving readability. The reading order is natural, from high-level logic down to helper methods. Minor deductions: `factorSum` could be slightly clearer by extracting a helper for prime factor iteration, and `isPrime` uses `Math.sqrt` without a comment, though the intent is clear enough. Overall, very readable.
Run 2
The code is well-structured into small, focused methods with clear responsibilities, making it highly readable. The main loop, digit sum, factor sum, and primality check are separated logically. Nesting is minimal—only one nested while loop inside a for loop—keeping the code relatively flat. Intent is clear from method names and the overall flow. Code length is concise without sacrificing clarity. Each line performs a single action, improving readability. The reading flow is natural: from problem statement (main) to verification (isSmithNumber) to helper methods. Minor deductions: factorSum recomputes digitSum for each factor rather than summing digits of the full factorization once, and the loop bound could be optimized, but these do not significantly impair readability.
Run 3
The code is highly readable due to clear method decomposition, shallow nesting, and logical organization. Each method has a single responsibility (digit sum, factor sum, primality check), making intent obvious. The main loop is concise, and lines are short with one action each. Variable names are descriptive. One minor improvement could be documenting the Smith number logic or optimizing factorSum to avoid redundant checks, but overall the structure supports excellent readability and maintainability.
Run 1
Code Structure: Well organized into small, focused methods for digit sums, factor sums, primality, and Smith-number detection. Nesting: Shallow overall; the nested factorization loop is manageable. Clarity of intent: Descriptive method names make the purpose clear, though the Smith-number definition and repeated-factor counting could benefit from brief comments. Code length: Concise without unnecessary boilerplate or repetition. Action granularity: Each statement performs a single clear action; the combined return condition remains easy to understand. Reading flow: The main loop introduces the task naturally, followed by the detection method and its helpers. Minor readability drawbacks include the unexplained upper bound of 10000 and modifying the number parameter during factorization.
Run 2
Code Structure: Well-organized into small, focused methods separating enumeration, Smith-number detection, digit summation, factor summation, and primality testing. Nesting: Shallow and manageable, with at most two control-flow levels per method. Clarity of intent: Descriptive method names make the overall purpose clear, though factorSum could more explicitly indicate summing the digits of prime factors, and the upper bound 10000 is unexplained. Code length: Concise without unnecessary abstraction or repetition. Action granularity: Each statement performs a distinct operation; loop headers use conventional Java syntax. Reading flow: Natural top-down progression from the entry point to supporting methods, aided by consistent formatting. Minor readability limitations include generic loop variables and mutating number during factorization, which requires readers to track the changing loop bound.
Run 3
Code Structure: Well-organized into small methods for digit sums, factor sums, primality, and Smith-number detection. Nesting: Shallow and manageable, with at most two nested control structures. Clarity of intent: Descriptive method names make the purpose clear, though factorSum could more explicitly indicate summing the digits of prime factors, and 10000 is an unexplained limit. Code length: Concise without unnecessary repetition or boilerplate. Action granularity: Each statement performs a single straightforward action. Reading flow: The entry point followed by the main predicate and supporting methods provides a natural progression; consistent formatting and early returns improve readability.