Source code
public class Main {
public static void main(String[] args) {
for (int i = 1; i <= 1000; i++) {
String output = "";
if (i % 2 == 0) {
output += "Foo";
}
if (i % 3 == 0) {
output += "Fizz";
}
if (i % 5 == 0) {
output += "Buzz";
}
if (i % 7 == 0) {
output += "Bar";
}
if (output.equals("")) {
System.out.println(i);
} else {
System.out.println(output);
}
}
}
}
Run 1
The code demonstrates excellent readability. The structure is logical: a single loop with sequential independent condition checks, each appending to a clear output variable. Nesting is minimal — all if statements are at the same level, avoiding deep indentation. The intent is immediately clear: this is a FizzBuzz-style variant printing special words for multiples of 2, 3, 5, and 7. The code is concise, without unnecessary abstraction. Each action is on its own line, and the final check using `output.equals("")` clearly distinguishes between printing the number or the accumulated string. The reading flow follows a natural top-to-bottom progression: initialize loop, build output, print result. One minor possible improvement would be using `output.isEmpty()` instead of `output.equals("")`, but this doesn’t meaningfully impact readability.
Run 2
The code is highly readable due to its straightforward structure and clear intent. It uses separate, flat if-statements rather than nested conditions, which keeps the logic easy to follow. Each condition maps to a specific output token, and the final check for an empty string cleanly decides whether to print the number or the accumulated string. Action granularity is good—each line performs one logical operation. The loop range is explicit. Minor deductions: the use of string concatenation for output building is acceptable at this scale, and a small improvement could be refactoring the logic into a helper method, but overall the code is easy to understand and maintain.
Run 3
The code is clearly structured with a straightforward loop and independent conditional checks, avoiding complex nesting. Intent is obvious: it generates a Foo-Fizz-Buzz-Bar style output for numbers 1–1000. Each action is on its own line, improving readability. The use of string concatenation is simple, though a helper method could reduce repetition. Overall, the code is concise, flat, and easy to follow.
Run 1
Code Structure: Logically organized around a single loop with independent divisibility checks and a final output decision. Nesting: Shallow and consistent; no deeply nested conditional chains. Clarity of intent: The extended FizzBuzz behavior is easy to understand, though named constants could clarify the upper limit and divisors. Code length: Concise, with minor repetition that remains easy to follow. Action granularity: Each statement performs one clear action on its own line. Reading flow: Natural progression from initializing output, through appending matching labels, to printing either the number or accumulated text. Using output.isEmpty() instead of output.equals("") would make the empty-string check slightly more idiomatic.
Run 2
Code Structure: A single loop with logically ordered divisibility checks is well organized. Nesting: Shallow and consistent, with no complicated conditional chains. Clarity of intent: The number-to-label substitution is easy to understand, though the divisors and labels are unexplained literals. Code length: Concise for its purpose; the final printing branch could be simplified slightly. Action granularity: Each statement performs one clear action, and independent checks correctly allow labels to accumulate. Reading flow: Initialization, label construction, and output proceed naturally from top to bottom. Consistent indentation and straightforward control flow make the code highly readable.
Run 3
Code Structure: Logically organized into a loop, independent divisibility checks, and a final output decision. Nesting: Shallow and easy to follow, with no complex nested conditionals. Clarity of intent: The number-to-label substitution behavior is clear, though the range and divisor-label mappings lack contextual explanation. Code length: Concise for its purpose; the final printing branch could be simplified slightly. Action granularity: Each statement performs one clear action, with conventional loop control. Reading flow: Natural top-to-bottom progression from initialization through label accumulation to printing. Consistent formatting supports readability. Using output.isEmpty() instead of output.equals("") would express the empty-string check more directly.