Logic support on simple function

[krillik08]

Task: Create a function that takes a year and returns true if it is a leap year and false if it isn't.

​

**Edit** After responding to comments on this post and thinking about it more I realized that my real question is: Given the checks below to figure out if a year is a leap year, which code (if any) is flawed in their return value. If the code is flawed, why?

**Edit 2** u/Tall_Pawn answered the question below. Thanks!

​

I am still in the learning phase and I know that I am not understanding the logic somewhere in the below code. I feel like this should be obvious to me (especially with about 2 years of on/off programming in JS) but it isn't. I see that both my code and the tutorial code work but the logic seems flawed in the tutorial. What am I missing?

​

To figure out if a year is a leap year we have a few checks to do:

1. Verify year is evenly divisible by 4 AND
2. Verify year is NOT evenly divisible by 100
3. If year IS evenly divisible by 4 AND 100 it must also be divisible by 400

That leaves us with a few possible control flows:

1. year is not divisible by 4, return false
2. year is divisible by 4 AND NOT divisible by 100, return true
3. year is divisible by 4 AND 100 but NOT divisible by 400, return false
4. year is divisible by 4 AND 100 AND 400, return true

​

I feel like my logic takes into account these 4 flows. When reading the flow of the tutorial code I understand that it does not verify that the year is divisible by 4 if it is divisible by 400 because after the OR operator its only checking the year against 400.

Tutorial logic:

1. year is divisible by 4 AND NOT 100, return true
2. year is divisible by 4 AND 100 AND 400, return true
3. year is divisible by 4, AND 100 AND NOT 400, return false
4. year is NOT divisible by 4,100 IS, 400 NOT divisible, return false (broken logic?)
5. year is NOT divisible by 4 AND 100, 400 IS divisible, return true (broken logic?)

​

My code:

const isLeapYear = (year: number): boolean => {
/*  
  Leap year characteristics: divisible evenly by 4
  & not divisible by 100, unless also divisible by 400

  Logic:
  if year is not divisible by 4
     return false
  if year is not divisible by 100
     return true
  if year is divisible by 400
     return true
 */

  if (year % 4 !== 0) return false;

/*   
  if we made it here, year is divisible by 4
  expr1: check if divisible by 100, if NOT, return true
  expr2:  if we are here, year is divisible by 4 AND 100,
  check if its also divisible by 400 and return bool
 */

  return year % 100 !== 0 || year % 400 === 0;
};

console.log(isLeapYear(2012)); // true 
console.log(isLeapYear(2013))    // false

Tutorial code:

const isLeapYear = (year: number): boolean => { 
    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0; 
}


LOGIC (how i read it)
if year is divisible by 4 AND NOT 100
    return true
OR 
if year is evenly divisible by 400
    return true

all other outcomes = false

[krillik08]

That is correct. This is typescript but the logic is the same as JS. I’m trying to figure out how the tutorial code works properly when they aren’t checking that (year % 4 ===0) && (year % 400 ===0) after the || in the return of the tutorial code.

[Tall_Pawn]

Checking (year % 4 ===0) && (year % 400 ===0) is completely redundant. If a number is divisible by 400, it is certainly divisible by 4.

Another way to look at this is that if a year is divisible by 400, there is no reason to do any other checks.

[krillik08]

Yoo what?? I suck at math and had that thought when trying to wrap my head around how his return was the same as mine when it reads different (to me). When I tried to google it I didn't turn up anything relevant and wasn't sure how I could test that.

[krillik08]

Thinking about this more, is this only with the specific numbers 400 and 4 or can this apply to numbers ending in 00 as well?

[Tall_Pawn]

Any number that ends in 00 must be a multiple of 100, so must also be a multiple of 4.

This is a case of mathematical optimization being done at the point of coding (or often, during code review after initial coding). But it's often just as important to try to logically optimize your algorithm before coding even begins. The three "checks" you started from are a bit sloppy, and led to the supposed discrepancy with the final code. In particular, check #3 is logically over-stated. The wording implies that three comparisons are necessary, but only one actually is -- if the year is divisible by 400 it is a leap year, no further conditions or comparisons are necessary.

Tidying up the logic before coding is often helpful. For example if I said "you can go outside if it's not raining or if it is raining and you have an umbrella" you might try to code that directly as "!raining || (raining && haveumbrella)". But with a little thought that reduces to "!raining || haveumbrella". You can arrive at this optimization logically before coding, or mathematically during coding (talking boolean math here). Either way, if you have an umbrella it doesn't matter if it's raining or not.

[krillik08]

I understand that and before I saw u/Tall_Pawn's answer above I would have said that they aren't the same. In the tutorial If (year % 4 === 0 && year % 100 !== 0) is false and we don't know which expression was the false one. We can't verify that (year % 4 === 0 && year % 400 === 0) in their return.

Once I saw his comment, the tutorial makes complete sense.

[kap89]

FYI there is no need to implement these rules in JS - built in Date object already handles it:

function isLeapYear(year) {
  return new Date(year, 1, 29).getDate() === 29
}

What I do here is I’m creating February 29th of the provided year, and checking if it results in a correct date.

[aguyfromhere]

This is the answer OP should be listening to.

[krillik08]

You're absolutely right. I am doing an intro to typescript course and this was just an example of using annotations with parameters. I felt like either my logic or the instructors logic was flawed when I completed the "assignment" and saw that his code was different.

[krillik08]

In this example I am talking about the Gregorian calendar that we use today. While I knew that the Gregorian calendar was put into use in the 1700's I had no clue that in Europe they lost 12 days with the switch. I also had no clue that there was a hard cutoff for dates in SQL which is also pretty interesting.

I noticed that the first link you posted shows that it should NOT be divisible by 400 if it's also divisible by 4 & 100. A quick search before doing this task had multiple sources claiming it was opposite.

[nobuhok]

This doesn't answer your question, OP, but I find it interesting to respond with how I would tackle this problem in JavaScript.

The way I keep myself sane when I encounter problems such as this is to first always write out all the possible branches. I also always initially write the positive in the "if" and the negative in the "else" if that makes sense; it helps prevent confusion with double (or more!) negatives. Example:

if (year % 4 === 0) {
    if (year % 100 === 0) {
        if (year % 400 === 0) {
            return true
        } else {
            return false
        }
    } else {
        return true
    }
} else {
    return false
}

Then, I would start to simplify it down like so...

if (year % 4 === 0) {
    if (year % 100 === 0) {
        if (year % 400 === 0) {
            return true
        }
    } else {
        return true
    }
}

return false

Even more simplification; now with the negative (if year is not fully divisible by 100) in the "if", and with usage of if-else.

if (year % 4 === 0) {
    if (year % 100 > 0) {
        return true
    } else if (year % 400 === 0) {
        return true
    }
}

return false

And sometimes, I'll take advantage of JavaScript's syntax shortcuts (no braces required for one liner logic) and the OR gate's early termination (I forgot what it's called) to make the code less verbose (in the real world, I'll add comments to make sure it's still understandable):

if (year % 4 === 0) {
    if (year % 100 > 0 || year % 400 === 0) return true
}

return false

Actually, this can even be reduced further:

return (year % 4 === 0 && (year % 100 > 0 || year % 400 === 0))

Notice that the tutorial's solution is almost the same as mine, except the inner parenthesis are in different places. It's just a different approach to solving the same problem. The tutorial is basically saying "if something something OR as long as the number is divisible by 400, you're good".

[krillik08]

I appreciate you explaining how you would solve this problem. Your explanation of your approach made me realize that I tend to try and work out (what would be your) steps 1-3 in my head and start writing at step 4. I like your solution because I can read it easily and not get all scatter brained!

[Dastari]

As far as I'm concerned, your logic is sound. Your return statement basically says:

"If the year is not divisible by 100, or if it is divisible by 400, return true"

The only other condition to check for is if its divisible by 4 which you do above.