I am trying to make a simple calculator to determine whether or not a certain year is a leap year.
By definition, a leap year is divisible by four, but not by one hundred, unless it is divisible by four hundred.
Here is my code:
def leapyr(n):
if n%4==0 and n%100!=0:
if n%400==0:
print(n, "is a leap year.")
elif n%4!=0:
print(n, "is not a leap year.")
print(leapyr(1900))
When I try this inside the Python IDLE, the module returns None. I am pretty sure that I should get 1900 is a leap year.
Use calendar.isleap:
import calendar
print(calendar.isleap(1900))
As a one-liner function:
def is_leap_year(year):
"""Determine whether a year is a leap year."""
return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
It's similar to the Mark's answer, but short circuits at the first test (note the parenthesis).
Alternatively, you can use the standard library's calendar.isleap, which has exactly the same implementation:
from calendar import isleap
print(isleap(1900)) # False
You test three different things on n:
n % 4
n % 100
n % 400
For 1900:
1900 % 4 == 0
1900 % 100 == 0
1900 % 400 == 300
So 1900 doesn't enter the if clause because 1900 % 100 != 0 is False
But 1900 also doesn't enter the else clause because 1900 % 4 != 0 is also False
This means that execution reaches the end of your function and doesn't see a return statement, so it returns None.
This rewriting of your function should work, and should return False or True as appropriate for the year number you pass into it. (Note that, as in the other answer, you have to return something rather than print it.)
def leapyr(n):
if n % 400 == 0:
return True
if n % 100 == 0:
return False
if n % 4 == 0:
return True
return False
print leapyr(1900)
(Algorithm from Wikipedia)
The whole formula can be contained in a single expression:
def is_leap_year(year):
return (year % 4 == 0 and year % 100 != 0) or year % 400 == 0
print n, " is a leap year" if is_leap_year(n) else " is not a leap year"
Your function doesn't return anything, so that's why when you use it with the print statement you get None. So either just call your function like this:
leapyr(1900)
or modify your function to return a value (by using the return statement), which then would be printed by your print statement.
Note: This does not address any possible problems you have with your leap year computation, but ANSWERS YOUR SPECIFIC QUESTION as to why you are getting None as a result of your function call in conjunction with your print.
Explanation:
Some short examples regarding the above:
def add2(n1, n2):
print 'the result is:', n1 + n2 # prints but uses no *return* statement
def add2_New(n1, n2):
return n1 + n2 # returns the result to caller
Now when I call them:
print add2(10, 5)
this gives:
the result is: 15
None
The first line comes form the print statement inside of add2(). The None from the print statement when I call the function add2() which does not have a return statement, causing the None to be printed. Incidentally, if I had just called the add2() function simply with (note, no print statement):
add2()
I would have just gotten the output of the print statement the result is: 15 without the None (which looks like what you are trying to do).
Compare this with:
print add2_New(10, 5)
which gives:
15
In this case the result is computed in the function add2_New() and no print statement, and returned to the caller who then prints it in turn.
A leap year is exactly divisible by 4 except for century years (years ending with 00). The century year is a leap year only if it is perfectly divisible by 400. For example,
if( (year % 4) == 0):
if ( (year % 100 ) == 0):
if ( (year % 400) == 0):
print("{0} is a leap year".format(year))
else:
print("{0} is not a leap year".format(year))
else:
print("{0} is a leap year".format(year))
else:
print("{0} is not a leap year".format(year))
If you don't want to import calendar and apply .isleap method you can try this:
def isleapyear(year):
if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0):
return True
return False
In the Gregorian calendar, three conditions are used to identify leap years:
The year can be evenly divided by 4, is a leap year, unless:
The year can be evenly divided by 100, it is NOT a leap year, unless:
The year is also evenly divisible by 400. Then it is a leap year.
This means that in the Gregorian calendar, the years 2000 and 2400 are leap years, while 1800, 1900, 2100, 2200, 2300 and 2500 are NOT leap years. source
def is_leap(year):
leap = False
if year % 4 == 0:
leap = True
if year % 4 == 0 and year % 100 == 0:
leap = False
if year % 400 == 0:
leap = True
return leap
year = int(input())
leap = is_leap(year)
if leap:
print(f"{year} is a leap year")
else:
print(f"{year} is not a leap year")
The logic in the "one-liner" works fine. From personal experience, what has helped me is to assign the statements to variables (in their "True" form) and then use logical operators for the result:
A = year % 4 == 0
B = year % 100 == 0
C = year % 400 == 0
I used '==' in the B statement instead of "!=" and applied 'not' logical operator in the calculation:
leap = A and (not B or C)
This comes in handy with a larger set of conditions, and to simplify the boolean operation where applicable before writing a whole bunch of if statements.
An alternative one liner:
((((y % 4) + (int((y - (y % 100)) / y) * ((y % 400) / 100))) - 1) < 0)
This was something that I put together for fun (?) that is also 1:1 compatible with C.
(y % 4) >>>It first checks if the year is a leap year via the typical mod-4 check.
(int((y - (y % 100)) / y) >>>It then accounts for those years divisible by 100. If the year is evenly divisible by 100, this will result in a value of 1, otherwise it will result in a value of 0.
((y % 400) / 100))) >>>Next, the year is divided by 400 (and subsequently 100, to return 1, 2, or 3 if it is not.
These two values
(int(y - (y % 100)) / y)
&
((y % 400) / 100)))
are then multiplied together. If the year is not divisible by 100, this will always equal 0, otherwise if it is divisible by 100, but not by 400, it will result in 1, 2, or 3. If it is divisible by both 100 and 400, it will result in 0.
This value is added to (y % 4), which will only be equal to 0 if the year is a leap year after accounting for the edge-cases.
Finally, 1 is subtracted from this remaining value, resulting in -1 if the year is a leap year, and either 0, 1, or 2 if it is not. This value is compared against 0 with the less-than operator. If the year is a leap year this will result in True (or 1, if used in C), otherwise it will return False (or 0, if used in C).
Please note: this code is horribly inefficient, incredibly unreadable, and a detriment to any code attempting to follow proper practices. This was an exercise of mine to see if I could do so, and nothing more.
Further, be aware that ZeroDivisionErrors are a consequence of the input year equaling 0, and must be accounted for.
For example, a VERY basic timeit comparison of 1000 executions shows that, when compared against an equivalent codeblock utilizing simple if-statements and the modulus operator, this one-liner is roughly 5 times slower than its if-block equivalent.
That being said, I do find it highly entertaining!
The missing part is the use of return statement:
def is_year_leap(year):
if year % 100 == 0:
if year % 400 == 0:
return True
else:
return False
elif year % 4 == 0:
return True
else:
return False
x = is_year_leap(int(input('Enter any year: ')))
print(x)
I tried solving in this way and it as work for me like a charm !!!
Logic I applied to find leap year or not
print([ (1900 % 4 == 0 ) , (1900 % 400 == 0) , (1900 % 100 == 0) ] )
print([ (2022 % 4 == 0 ) , (2022 % 400 == 0) , (2022 % 100 == 0) ] )
print([ (2000 % 4 == 0 ) , (2000 % 400 == 0) , (2000 % 100 == 0) ] )
print([ (1896 % 4 == 0 ) , (1896 % 400 == 0) , (1896 % 100 == 0) ] )
print([ (2020 % 4 == 0 ) , (2020 % 400 == 0) , (2020 % 100 == 0) ] )
Output :
[True, False, True]
[False, False, False]
[True, True, True]
[True, False, False]
[True, False, False]
My code :
yy = 2100
lst = [ (yy % 4 == 0) , (yy % 400 == 0) , (yy % 100 == 0) ]
if lst.count(True) in [0,2]:
print('Not Leap Year')
else:
print('Leap Year')
Output :
Not Leap Year
Incase you find any issue in my code feel free to guide me
From 1700 to 1917, official calendar was the Julian calendar. Since then they we use the Gregorian calendar system. The transition from the Julian to Gregorian calendar system occurred in 1918, when the next day after January 31st was February 14th. This means that 32nd day in 1918, was the February 14th.
In both calendar systems, February is the only month with a variable amount of days, it has 29 days during a leap year, and 28 days during all other years. In the Julian calendar, leap years are divisible by 4 while in the Gregorian calendar, leap years are either of the following:
Divisible by 400.
Divisible by 4 and not divisible by 100.
So the program for leap year will be:
def leap_notleap(year):
yr = ''
if year <= 1917:
if year % 4 == 0:
yr = 'leap'
else:
yr = 'not leap'
elif year >= 1919:
if (year % 400 == 0) or (year % 4 == 0 and year % 100 != 0):
yr = 'leap'
else:
yr = 'not leap'
else:
yr = 'none actually, since feb had only 14 days'
return yr
Related
def leap(year):
return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
I am new to python. I am writing a program that should take a year as input and return a Boolean whether the year is a leap year or not. Above is the code of my professor which I am trying to understand but I am not sure why my professor is using (year % 100 != 0 or year % 400 == 0)
% is a modulo operator in Python.
https://docs.python.org/3/reference/expressions.html
% 100 is being used to check if the year is divisible by 100 or not. This is because 200 is also divisible by 4 but it's not a leap year. For a leap year, you require 4 and 100 to be multiples. However, % 400 is not required.
I am sorry to say that I start to practice for solving Python Programming in HackerRank but I faced a problem which is know as test case error.Need help for resolving my current problems.
below the problem explanation in HackerRank,
An extra day is added to the calendar almost every four years as February 29, and the day is called a leap day. It corrects the calendar for the fact that our planet takes approximately 365.25 days to orbit the sun. A leap year contains a leap day.
In the Gregorian calendar, three conditions are used to identify leap years:
The year can be evenly divided by 4, is a leap year, unless:
The year can be evenly divided by 100, it is NOT a leap year, unless:
The year is also evenly divisible by 400. Then it is a leap year.
This means that in the Gregorian calendar, the years 2000 and 2400 are leap years, while 1800, 1900, 2100, 2200, 2300 and 2500 are NOT leap years. Source
Task
Given a year, determine whether it is a leap year. If it is a leap year, return the Boolean True, otherwise return False.
Note that the code stub provided reads from STDIN and passes arguments to the is_leap function. It is only necessary to complete the is_leap function.
Input Format
Read year, the year to test.
Constraints
1900<=year<=10**5
Output Format
The function must return a Boolean value (True/False). Output is handled by the provided code stub.
Sample Input 0
1990
Sample Output 0
False
Explanation 0
1990 is not a multiple of 4 hence it's not a leap year.
Below The code which I submitted:
def is_leap(year):
leap = False
if year%4==0:
if year%100==0:
if year%400==0:
return True
else:
return False
else:
return False
else:
return False
return leap
year = int(input())
Note: after submission it show the Test case Failed
I think you had some trouble understanding the question. The conditions for a year to be a leap year is:
it should be divisible by 4 but not by 100
OR
it should be divisible by 400.
This means that:
400 -> leap year.
100 -> divisible by 4 but still not a leap year because it is divisible by 100.
4 -> leap year.
So basically, we have to check if a year is divisible by 4 but not by 100, OR if it is simply divisible by by 400.
The Python code for this will be:
def is_leap(year):
if year%4==0 and year%100!=0:
return True
if year%400==0:
return True
return False
You don't need too many return statements because if the first condition was true, it would never go to the next statement. If the code returns True at any point in this function then it would never reach False. The only way the control would go to return False is if none of the conditions held True.
Condition for leap year given in the condition
if the input is evenly divisible by 4 and not by 100(evenly
divisible) then it is a leap year
if the input is evenly divisible by 100 and 400 then it is a leap year
Code
def is_leap(year):
if 1900 <= year <= 10**5:
if (year % 4 == 0 and year % 100 != 0) or (year % 100 == 0 and year % 400 == 0):
return True
return False
return False
year = int(input())
This will satisfy all the test cases.
I think the point here is that you see the conditions are separated from each other.you have to cover all these three conditions.
def is_leap(year):
leap = False
if year % 4 == 0 and year % 100 != 0:
leap = True
elif year % 100 !=0 and year % 400 == 0:
leap = True
elif year % 400 == 0 and year % 4 == 0:
leap = True
return leap
year = int(input())
print(is_leap(year))
I am trying to solve this question with this code:
is_leap_year = False
not_leap_year = True
input_year = int(input())
if (input_year % 4 == 0 or input_year % 400 == 0):
print(input_year, '- leap year')
elif (input_year % 4 != 0 and input_year % 400 != 0):
print(input_year, '- not a leap year')
Why is my code still reading 1900 as a leap year?
Divisibility by 400 is an exception to the rule that years divisible by 100 are not leap years, which itself is an exception to the rule that years divisible by 4 are leap years. If you wrote it out in sequence, you might write
if year % 400 == 0: # Some centuries are leap years...
print("leap year")
elif year % 100 == 0: # ... but most are not ...
print("not leap year")
elif year % 4 == 0: # ... even though other divisibly-by-four years are
print("leap year")
else:
print("not leap year")
or work your way up
if year % 4 != 0:
print("not a leap year")
elif year % 100 != 0:
print("leap year")
elif year % 400 != 0:
print("not a leap year")
else:
print("leap year")
Combining these into a single test would be something like
if year % 4 != 0 or (year % 100 == 0 and year % 400 != 0):
print("not a leap year")
else:
print("leap year")
which I find a little harder to follow than a series of simple tests.
(Given the nature of a solar year, making every year divisible by 400 a leap year is also a problem, though not as big a one as making every century year a leap year. People wanting to avoid drifts over the millenia will propose additional exceptions like "years divisible by 4000, or 40,000, or something, should not be leap years"; no official rule exists yet, though.)
Because 1900 % 4 is actually 0, so the first if conditional is True ( True or False is True) and then it doesn't execute the second if block because is an elif (else if, and since the first was True, there is no need to execute the else part).
Try like this!
year = int(input("Input year: "))
if year % 4 == 0:
print("Year is leap.")
if year % 100 == 0 and year % 400 != 0:
print("Year is common.")
else:
print("Year is common.")
Because the first condition input_year % 4 == 0 evaluates to True.
1900/4= 475 => input_year%4 == 0 is True => for your code 1900 is a leap year
1901/4 = 475,25 => input_year%4 == 0 is false => for your code 1901 is not a leap year
1900 is not a leap year, your calculation is not correct.
here is the code for leap year calculation:
if (year % 4) == 0:
if (year % 100) == 0:
if (year % 400) == 0:
print("{0} is a leap year".format(year))
else:
print("{0} is not a leap year".format(year))
else:
print("{0} is a leap year".format(year))
else:
print("{0} is not a leap year".format(year))
You can write a simplified function taking advantage of Truthy/Falsely
if not(year % 400) or (not(year % 4) and year % 100) : return True
return False```
print(isLeapYear(1900)) # False
print(isLeapYear(1896)) # True
Instead of "or" use "and" in the first if statement.
Both conditions need to be met.
I have started learning Python and came across this code:This is leap year program.
Why are we defining leap = False .The output will be true or false.
def is_leap(year):
leap = False
return year % 4 == 0 and (year % 400 == 0 or year % 100 != 0)
year = int(input())
print(is_leap(year))
We don't need to define leap=False since it is not being used in the code, so you can just remove it and do.
def is_leap(year):
return year % 4 == 0 and (year % 400 == 0 or year % 100 != 0)
year = int(input())
print(is_leap(year))
A bad way to write this and use leap will be
def is_leap(year):
leap = year % 4 == 0 and (year % 400 == 0 or year % 100 != 0)
return leap
year = int(input())
print(is_leap(year))
The leap variable in this function isn't even used, and as you assumed, that line is just redundant, and can (should!) be removed.
I am new to python. i am writing a program that should take an year as input and return a boolean whether the year is a leap year or not. the code i have written does not return anything. where is my mistake?:
def leap_y(year):
leap = False
if year % 4 == 0 and (year % 400 == 0 or year % 100 == 0):
leap = True
return leap
year = int(input())
You should actually "call" the function. Instead of:
year = int(input())
You must write:
year = leap_y(input())