Source code
public class PerniciousNumbers {
public static void main(String[] args) {
for(int i = 0; i <= 10000; i++) {
if(isPernicious(i))
System.out.println(i);
}
}
public static boolean isPernicious(int num) {
int sum = 0;
String binary = Integer.toBinaryString(num);
for(int i = 0; i < binary.length(); i++)
sum += Integer.parseInt(String.valueOf(binary.charAt(i)));
return isPrime(sum);
}
public static boolean isPrime(int num) {
if(num <= 1)
return false;
for(int i = 2; i <= Math.sqrt(num); i++) {
if(num % i == 0)
return false;
}
return true;
}
}
Run 1
The code is fairly readable with clear method separation and simple logic. Structure is logical with dedicated methods for perniciousness and primality checks. Nesting is minimal, mostly flat loops and conditionals. Intent is mostly clear, though the bit-summing via string conversion is somewhat indirect. Code length is concise. Action granularity is reasonable, with one main action per line despite single-line if statements without braces, which slightly reduces clarity. Reading flow is natural, top-down from main to helper methods. Improvements could include handling the digit sum via bit manipulation for clarity and adding braces for consistency.
Run 2
The code is logically organized into three clear methods, each with a single responsibility: main loop, pernicious check, and primality check. Nesting is minimal, and reading flow is straightforward. Variable names are meaningful, and intent is mostly clear. However, line-level readability suffers slightly from packed actions—e.g., in `isPernicious`, `sum += Integer.parseInt(String.valueOf(binary.charAt(i)))` combines character extraction, conversion, parsing, and accumulation into one line, reducing clarity and action granularity. Also, `if` statements without braces are terse but can be less safe and slightly harder to scan. Overall, the code is concise and maintainable but could benefit from a helper line that makes the bit-summing process more explicit.
Run 3
The code has a clear overall structure with three distinct methods and a straightforward main loop, making the high-level purpose understandable. However, readability suffers from several issues: inconsistent brace style (single-line if/for without braces), nested method calls in isPernicious that obscure intent, and unnecessary string conversion overhead. The method names are descriptive but lack comments explaining what makes a number 'pernicious'. The reading flow is mostly natural from main to helper methods, but the dense binary-parsing loop is less intuitive. Action granularity could be improved by extracting the digit-summing logic. Overall, it's functional but not idiomatic or self-documenting.
Run 1
Code Structure: Three focused methods logically separate enumeration, pernicious-number detection, and primality testing. Nesting: Shallow loops and conditionals keep complexity low. Clarity of intent: Method names communicate purpose, but 'sum' would be clearer as 'setBitCount', and 10000 is an unexplained limit. Code length: Concise overall, although converting each binary character through String.valueOf and Integer.parseInt makes bit counting unnecessarily cumbersome. Action granularity: Each statement performs one main action, with no crowded lines. Reading flow: Methods follow a natural top-down progression. Inconsistent spacing and omitted braces around single-statement branches and loops slightly reduce readability.
Run 2
1. Code Structure: Well organized into three focused methods for enumeration, pernicious-number detection, and primality testing. 2. Nesting: Shallow loop-and-condition nesting makes control flow easy to follow. 3. Clarity of intent: Method names clearly communicate purpose, though sum would be clearer as setBitCount, and the string-based bit counting requires some interpretation. 4. Code length: Concise overall, but converting individual binary characters into strings and parsing them is unnecessarily verbose. 5. Action granularity: Each line generally performs one action, with conventional loop headers and a slightly dense parsing expression. 6. Reading flow: Natural top-down progression from main to helper methods. Consistent indentation helps, while omitted braces and tight spacing slightly reduce readability.
Run 3
Code Structure: Three focused methods cleanly separate enumeration, pernicious-number detection, and primality testing. Nesting: Shallow loops and conditionals make control flow easy to follow. Clarity of intent: Method names communicate purpose, though 'sum' could more clearly describe the count of set bits, and 10000 is an unexplained limit. Code length: Compact without excessive abstraction; converting each binary character through String.valueOf and Integer.parseInt is unnecessarily verbose. Action granularity: Statements generally perform one action per line. Reading flow: Methods appear in a natural top-down order, and early returns simplify primality testing. Missing braces around several control-flow bodies and inconsistent spacing slightly reduce readability.