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!