Source code
public class LeapYear {
public static void main(String[] args) {
int startYear = 1800;
int endYear = 2400;
for(int year=startYear; year<=endYear; year++) {
if (year % 4 == 0) {
if (year % 100 == 0) {
if (year % 400 == 0) {
System.out.print(year + ", ");
}
}
else {
System.out.print(year + ", ");
}
}
}
}
}
Run 1
The code is structured logically with a clear main method and a simple loop. However, nesting is deeper than necessary due to the three-level if/else chain for the leap year rule. The purpose is understandable, but adding a comment would improve intent clarity. The code is concise but could be shorter by combining the conditions. Action granularity is one action per line, which is good. The reading flow is mostly natural, but the nested conditionals require extra effort to follow. Overall, it's readable but could be improved by flattening the logic into a single boolean expression.
Run 2
The code has a clear overall purpose: print leap years in a range. Structure is simple, but the leap year logic is implemented with three nested if statements, which increases nesting and reduces readability. Although each condition is on its own line, the repeated print statement and embedded logic make the intent somewhat harder to grasp at a glance. The approach is concise but not the most elegant; a combined boolean expression would flatten the nesting and better express the leap year rule. Variable names are clear, and the loop is straightforward, but the nesting and duplication weaken clarity and reading flow.
Run 3
The code is logically organized and fairly readable, but it has some structural issues. It uses nested `if` statements for leap year logic, which creates three levels of nesting and makes the logic less clear than it could be. The intent is understandable—printing leap years in a range—but the logic could be simplified for better clarity. The code is concise and each action is on its own line, aiding readability. However, the reading flow is slightly disrupted by the nested structure and the duplicated `System.out.print` statement. The class and variable names are clear. Overall, it is readable but could be improved by flattening the nesting (e.g., using logical operators) and reducing duplication.
Run 1
Code Structure: Logically organized, with range initialization followed by iteration and leap-year checks. Nesting: Three nested conditionals inside the loop add avoidable complexity; a combined boolean condition would be flatter. Clarity of intent: The class name, variable names, and divisibility checks make the purpose clear. Code length: Short overall, but duplicated print statements and nested branches make it longer than necessary. Action granularity: Each statement performs a single action; the loop header uses conventional initialization, condition, and increment. Reading flow: Execution proceeds naturally, though inconsistent spacing and the separated else placement slightly hinder scanning.
Run 2
Code Structure: Logically organized into initialization, iteration, leap-year checks, and output. Nesting: Three nested conditionals inside the loop add avoidable complexity; a combined boolean condition would be flatter. Clarity of intent: The class name and descriptive year variables clearly communicate the purpose, while the divisibility checks express the leap-year rules. Code length: Short overall, though the duplicated print statement and nested branches could be simplified. Action granularity: Statements generally perform one action per line; the loop header follows standard Java conventions. Reading flow: Execution proceeds naturally, but inconsistent spacing and the separated else placement slightly disrupt scanning.
Run 3
Code Structure: Logically organized around a year range, loop, and leap-year checks. Nesting: Three nested conditionals inside the loop add unnecessary depth; a single combined condition would be easier to scan. Clarity of intent: The class name and descriptive variables clearly convey the purpose, although the leap-year rule requires tracing branches. Code length: Short overall, but duplicated print statements and nested branches could be consolidated. Action granularity: Each statement performs one clear action; the standard for-loop header is appropriate. Reading flow: Execution proceeds naturally from setup to iteration and output, but inconsistent spacing and the separated else placement slightly interrupt scanning.