Source code
public class NumberPrinter {
public static void main(String[] args) {
for (int i = 1; i <= 1000; i++) {
boolean isMultipleOfTwo = i % 2 == 0;
boolean isMultipleOfThree = i % 3 == 0;
boolean isMultipleOfFive = i % 5 == 0;
boolean isMultipleOfSeven = i % 7 == 0;
if (isMultipleOfTwo) {
System.out.print("Foo");
}
if (isMultipleOfThree) {
System.out.print("Fizz");
}
if (isMultipleOfFive) {
System.out.print("Buzz");
}
if (isMultipleOfSeven) {
System.out.print("Bar");
}
if (!isMultipleOfTwo && !isMultipleOfThree && !isMultipleOfFive && !isMultipleOfSeven) {
System.out.print(i);
}
System.out.println();
}
}
}
Run 1
The code is highly readable. It uses a clear, flat structure with boolean variables naming conditions directly (isMultipleOfTwo, etc.), which aids clarity. Nesting is minimal—logic is linear and sequential. Action granularity is strong: each print statement is on its own line. Reading flow is natural, from condition setup to output. Minor deductions: the final condition ‘if not multiple of any’ is verbose and could be replaced by an ‘else’ pattern or a flag; the code is slightly repetitive in the four independent if-blocks, but this actually improves readability. Overall, very clear and logically organized.
Run 2
The code is highly readable with a clear, flat structure. It uses descriptive boolean variables to capture divisibility checks, making intent explicit. Each action is on its own line, and the logic follows a natural top-to-bottom flow. The repeated 'if' blocks are simple and avoid deep nesting. The final condition could be slightly simplified, but overall the code is concise, well-organized, and easy to follow.
Run 3
The code is well-structured and highly readable. It uses clear variable names to express intent, avoids deep nesting with flat boolean checks and independent if statements, and maintains one action per line. The logic is easy to follow: compute divisibility, print corresponding words, default to the number if nothing printed, then print a newline. The code is concise without being cryptic. Minor improvements could include extracting the word-mapping logic into a helper method or using a map to reduce repetitive boolean checks, but as is, the code is straightforward and maintainable.
Run 1
Code Structure: Logically organized into divisibility checks, conditional output, and a newline. Nesting: Shallow and consistent, with only a loop and simple conditionals inside main. Clarity of intent: Descriptive boolean names clearly communicate each divisibility test; independent if statements make concatenated output explicit. Code length: Reasonably concise, though repeated print blocks and the long fallback condition add minor verbosity. Action granularity: Each statement performs one clear action, making execution easy to follow. Reading flow: Natural top-to-bottom progression with useful blank-line grouping. The narrow indentation and absence of a brief explanation for the custom Foo/Fizz/Buzz/Bar mapping slightly reduce readability.
Run 2
Code Structure: Logically organized into divisibility checks, conditional output, a numeric fallback, and a newline. Nesting: Shallow and consistent, with simple conditionals inside one loop. Clarity of intent: Descriptive boolean names make the rules clear, although the output tokens and upper limit are unexplained literals. Code length: Concise overall; repeated conditionals are straightforward rather than unnecessarily verbose. Action granularity: Each statement performs one action, making execution easy to follow. Reading flow: Natural top-to-bottom progression, with blank lines separating phases. Minor readability drawbacks are minimal indentation and the long fallback condition.
Run 3
Code Structure: Logically organized into divisibility checks, corresponding output, a numeric fallback, and a newline. Nesting: Shallow and consistent, with only a loop and simple conditionals inside main. Clarity of intent: Descriptive boolean names make each rule explicit; independent if statements clearly allow concatenated output. Code length: Appropriately concise, though the fallback condition is somewhat long and repetitive. Action granularity: Each statement performs one clear action, with no compressed multi-action lines. Reading flow: Natural top-to-bottom progression, aided by blank lines separating phases. Minor readability drawbacks include minimal indentation and unexplained token choices and range constants.