Source code
public class PerniciousNumbers {
public static void main(String[] args) {
for (int i = 0; i <= 10000; i++) {
String binary = Integer.toBinaryString(i);
int sum = 0;
for (int j = 0; j < binary.length(); j++) {
if (binary.charAt(j) == '1') {
sum++;
}
}
boolean isPrime = true;
for (int j = 2; j <= sum / 2; j++) {
if (sum % j == 0) {
isPrime = false;
break;
}
}
if (isPrime && sum > 1) {
System.out.println(i);
}
}
}
}
Run 1
The code is generally structured clearly with straightforward loops and conditional logic. Nesting is minimal, and each action is relatively granular. However, the intent is not purposefully conveyed: 'sum' and 'isPrime' are vague, and the logic for prime checking is simplistic and not separated into methods. Loops are a bit long and repetitive, reducing readability for larger ranges. The code could benefit from method extraction and semantic naming.
Run 2
The code is logically structured and easy to follow at a high level: it generates numbers, computes the binary ones count, checks if the count is prime, and prints qualifying numbers. Nesting is shallow, with only two nested loops inside the main loop, and each action is clearly separated by line. However, readability is reduced by embedding the prime-checking logic and binary processing directly in the main method, which mixes levels of abstraction and obscures the overall intent. Variable names like 'sum' and 'isPrime' are fairly clear, but 'sum' would be better named 'popCount' or 'oneCount' to reflect its purpose. The prime-checking loop uses `sum / 2` which is slightly less intuitive than `Math.sqrt(sum)`. Overall, the code is decently readable for a small script-style task, but could benefit from helper methods and clearer naming.
Run 3
The code is functional but has moderate readability issues. Structure is straightforward but monolithically contained in main. Nesting is acceptable—only two levels deep. Intent is somewhat clear but not explicit: 'pernicious number' concept is not evident from variable names. Code length is reasonable but could be shorter with helper methods. Action granularity is mostly one action per line, which is good. Reading flow is decent but interrupted by inline prime-check logic. Major issues: prime-checking loop condition uses sum/2 without handling sum < 2 cleanly; checking sum > 1 only after full prime loop is inefficient; no separation of concerns. Overall, the logic works for small ranges but lacks modularity, making it less maintainable. Could be improved by extracting isPrime() and countSetBits() methods for clarity and reuse.
Run 1
Code Structure: Logically organized into counting set bits, checking primality, and printing results, though helper methods would better separate these responsibilities. Nesting: Moderate nesting from loops and conditionals is manageable but adds some reading effort. Clarity of intent: The class name and binary conversion suggest the purpose; however, sum is less descriptive than setBitCount, and the significance of the 10000 limit is unexplained. Code length: Concise overall, though Integer.bitCount could replace the string-based counting loop. Action granularity: Each statement performs a single clear action, with no densely packed operations. Reading flow: Execution proceeds naturally from candidate selection to counting, testing, and output; spacing between these stages would improve visual readability.
Run 2
Code Structure: Logically organized into binary conversion, counting set bits, checking primality, and printing results, though helper methods would separate responsibilities more clearly. Nesting: Moderate nesting from loops and conditionals is manageable but adds visual depth. Clarity of intent: The algorithm is understandable, but names such as sum and j are generic; setBitCount would communicate intent better. Code length: Compact without unnecessary verbosity, although Integer.bitCount could simplify the counting step. Action granularity: Statements generally perform one action per line; conventional loop headers remain easy to read. Reading flow: Execution follows a natural sequence, with consistent indentation, but blank lines between processing stages would improve scanning.
Run 3
Code Structure: Logically organized into binary conversion, counting set bits, primality testing, and printing, though helper methods would better separate responsibilities. Nesting: Moderate nesting from loops and conditionals remains easy to follow. Clarity of intent: The class name and isPrime convey purpose, but sum would be clearer as setBitCount, and the upper limit is unexplained. Code length: Compact without unnecessary verbosity. Action granularity: Most lines perform one clear action; conventional loop headers do not hinder readability. Reading flow: The sequential progression is natural, with consistent indentation, although blank lines between processing stages would improve scanning.