Source code
public class PerniciousNumber {
public static void main(String[] args) {
int limit = 10000;
for (int i = 0; i <= limit; 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 k = 2; k < sum; k++) {
if (sum % k == 0) {
isPrime = false;
break;
}
}
if (isPrime) {
System.out.println(i);
}
}
}
}
Run 1
The code is straightforward and readable. The structure is logical, moving from input generation to bit summation, primality check, and output. Nesting is shallow (maximum two levels), which helps maintain clarity. Each loop and conditional has a clear purpose, and actions are generally one per line. However, there are minor readability issues: 'isPrime' is computed for every number, including 0 and 1 (for which the loop doesn’t run), and the variable names like 'sum' and 'isPrime' are slightly generic. Extracting the bit-counting and prime-checking into helper methods would improve clarity and modularity, but as-is, the code remains easy to follow for a small utility.
Run 2
The code is logically organized and follows a clear sequence: convert to binary, count ones, check primality, and print. However, several readability issues reduce the score. The nesting depth is moderate but could be flatter; the primality check uses an unnecessary boolean variable and fails for sum = 2 (returns true incorrectly, though the loop still works for that case). Variable names like 'k' and 'j' are less descriptive. The code length is fairly concise, but extracting helper methods (e.g., isPrime, countBits) would improve clarity and reduce nested logic. Action granularity is mostly one action per line, which is good. The reading flow is natural top-to-bottom, but the primality logic would benefit from early return or a separate method. Overall, the code is understandable but lacks clean decomposition and has a minor logic edge case.
Run 3
The code is logically organized with clear separation of concerns: binary conversion, counting bits, prime checking, and output. Nesting is moderate with one inner loop and a second loop for prime validation. Intent is understandable but would benefit from helper method names like 'isPrime' or 'countSetBits' to self-document the logic. The code is concise but lacks guard clauses for edge cases (e.g., sum < 2). Action granularity is good, one statement per line. Reading flow is natural top-to-bottom, but the prime-check loop starts at 2, which is inefficient and slightly unclear for sum=1 or 0. Overall, readable but not highly polished.
Run 1
Code Structure: The program logically groups iteration, counting binary ones, primality testing, and output, though helper methods would separate responsibilities better. Nesting: Loop-and-conditional nesting is moderate and easy to follow. Clarity of intent: The class name and binary conversion suggest the purpose, but 'sum' would be clearer as 'bitCount', and the pernicious-number condition is not explained. The primality check incorrectly treats counts of 0 and 1 as prime, making its behavior inconsistent with its apparent intent. Code length: Compact without unnecessary verbosity, although standard bit-counting utilities could simplify it. Action granularity: Each statement performs one clear action; loop headers use conventional syntax. Reading flow: Consistent formatting and blank lines provide a natural progression through the algorithm.
Run 2
Code Structure: Logically organized into binary conversion, bit counting, primality testing, and output, but helper methods would separate responsibilities better. Nesting: Moderate nesting is easy to follow, though loops containing conditionals add depth. Clarity of intent: The class name and operations suggest finding pernicious numbers, but 'sum' would be clearer as 'setBitCount'. Initializing isPrime to true without rejecting counts below 2 incorrectly treats 0 and 1 as prime, undermining intent. Code length: Compact without unnecessary verbosity; Integer.bitCount could simplify counting. Action granularity: Each statement performs one clear action. Reading flow: Consistent indentation and blank lines make the progression natural, although named helper methods would make the algorithm easier to scan.
Run 3
Code Structure: The counting, primality checking, and printing stages are logically grouped, though helper methods would improve separation. Nesting: Moderate nesting of loops and conditionals remains manageable. Clarity of intent: Binary conversion and counting are clear, but 'sum' would be clearer as 'oneCount', and the definition of a pernicious number is implicit. The primality check also incorrectly treats counts of 0 and 1 as prime, undermining confidence in the expressed intent. Code length: Compact without unnecessary verbosity. Action granularity: Each statement performs a single action, with conventional loop headers. Reading flow: Execution proceeds naturally from conversion to counting to testing to output, supported by whitespace between stages.