Leap Year Calculator Using If Elif and Else Only

Question

I'm taking the 100 Days of Code (Python) taught by Angela Yu on Udemy. There have been a few other questions revolving around this lesson but I can't find one who came up with my specific question so I do apologize if it's out there somewhere.

The course is asking us to check whether or not a year is a leap year using the below flow chart:

If not cleanly divisible by 4 - Not a leap year.
If is cleanly divisible by 4 but not cleanly divisible by 100 - A leap year
If is cleanly divisible by 4, and by 100, but not cleanly divisible by 400 - Not a leap year
If is cleanly divisible by 4, is cleanly divisible by 100 and if is cleanly divisible by 400 - Leap year

The code I came up with does generate the desired outputs and passes the checks required to finish the lesson. I've tested it against a good two dozen years and it's correctly identified whether or not the year was a leap year each time. I'm not getting any syntax errors either. Most of my solutions to the lessons so far have had small variations but this one feels moreso than any of the rest and it's making me question its validity.

The point of the lesson is to get acclimated with if/elif and else statements, so I'm not trying to optimize it or use any more advanced/efficient/shorter keywords. The instructor provides their own solution but does specify there are other ways to go about it.

Is mine just structured poorly? Is there a scenario where it wouldn't work? Again, limiting it to only if/elif and else keywords is very much intentional.

My code:

year = int(input())

if year % 4 != 0:
  print ("Not leap year")
elif year % 100 != 0:
  print ("Leap year")
elif year % 400 !=0:
  print ("Not leap year")
else:
  print ("Leap year")

Instructor:

year = int(input())

if year % 4 == 0:
  if year % 100 == 0:
    if year % 400 == 0:
      print("Leap year")
    else:
      print("Not leap year")
  else:
    print("Leap year")
else:
  print("Not leap year")

Answer 1

Your code is nice. Contrasting to the instructor's solution, you have cleanly inverted the arrow anti-pattern to be as 'flat' as possible. I like your code more.

Some possibly uninteresting feedback:

• Using 2 spaces for indentation is abnormal with Python. Python users typically use 4 spaces for indentation.
  I can understand a JavaScript developer, amoungst some other languages, using 2 spaces for indentation. Or if you're working in a cross language project.

• Putting a space between the function name print and the opening bracket ( is abnormal. I may be wrong, but I think the convention is abnormal in most programming languages.

• By changing your code to a function we can easily test if your code is correct. "I've tested it against a good two dozen years" must have been a bit of a pain. We can use calendar.isleap() to test.

• Personally I try to keep the left side of lines as small as possible and keep the right larger. When reading the following code the small != 0 can easily be skimmed over.

  if really_long_function_name(really_long_variable_name, another_variable) != 0:
  

• I like the consistancy of your if statements, always using !=.

import calendar


def is_leap_year(year: int) -> bool:
    if 0 != year % 4:
        return False
    elif 0 != year % 100:
        return True
    elif 0 != year % 400:
        return False
    else:
        return True


if __name__ == "__main__":
    for year in range(1, 10_000):
        assert is_leap_year(year) == calendar.isleap(year), f"{year} is mismatched"
    print("All the results are correct!")

One thing to note is we don't actually need to use if statements. If we change to using == then we know %4 is a leep year, %100 cancels out some leap years, and %400 cancels out some cancels out. So we can instead use - to cancel the 100s and + to readd the 400s.

def is_leap_year__ray(year: int) -> bool:
    return bool(
        (0 == year % 4)
        - (0 == year % 100)
        + (0 == year % 400)
    )


if __name__ == "__main__":
    for year in range(1, 10_000):
        assert is_leap_year__ray(year) == calendar.isleap(year), f"{year} is mismatched"
    print("All the results are correct!")

Note: Python's calendars.isleap() source actually uses and and or to perform the canceling which allows for better performance than my code.

Answer 2

There is already a good answer but the code isn't the simplest.

A year is a leap year if it is divisible by 4 and not divisible by 100 or it is not divisible by 400. We can use modulus operator to check divisibility, the number is exactly divisible if the remainder is 0. 0 equals False so we can use not to negate it and check when it is False.

We can use and or logic operators to chain the statements.

So the code can be simply written as:

def is_leap_year(year: int) -> bool: 
    return not year % 4 and year % 100 > 0 or not year % 400