Calculate the day of the week for any date in your head

Here's the easiest way I’ve seen [1] to determine if a year is a leap year:

If the last two digits of the year are 00, throw them away and keep only the first two digits. Otherwise, keep only the last two digits. The year is a leap year if what you kept is divisible by 4.

Examples:

- The year 1705 does not end in 00, so throw away 17 and keep 05. 05 is not divisible by 4, so 1705 is not a leap year.

- The year 2000 ends in 00, so throw away 00 and keep 20. 20 is divisible by 4, so 2000 is a leap year.

The standard method [2] is more complicated:

> Years that are divisible by four are leap years, with the exception of years that are divisible by 100, which are not leap years, and with the final exception of years divisible by 400, which are.

[1] https://twitter.com/jordancurve/status/1012203999716618240

[2] https://www.theguardian.com/science/2011/feb/28/leap-year-al...

If not for religious groups, we could have had World Calendar and all this would be unnecessary: https://en.m.wikipedia.org/wiki/World_Calendar.

This looks like an algorithm that could be useful if programmed rather than carried around in one's head.

It also still requires a lookup to bootstrap it: the day-of-week of the last day of February for the selected year. So it's a clever and well-observed compilation of identified patterns, but not self-contained.

My Autistic son does this in a couple of seconds. He can only really do the last 50 years tho.

Savants who do this are called "human calendars".

A simpler and easier way to calculate the day of the week for any date is the First Sunday Doomsday algorithm: http://firstsundaydoomsday.blogspot.com/2009/12/quick-start-...

(There’s also a earn-by-example page: http://firstsundaydoomsday.blogspot.com/2011/01/learn-by-exa...)

Using Sundays rather than doomsdays simplifies the arithmetic. Another improvement the above approach incorporates is the odd+11 rule for calculating the year code.

For all but the most basic details my rule is that if I have to remember it, the system is broken. I know a small handful of passwords off the top of my head, a few email addresses, my wife's and my phone numbers, and the phone number of my home during childhood. (I'm obviously exaggerating, you know, for dramatic effect.) This trick requires so many mnemonic devices that it makes my head spin. It's still impressive if you can do it. Just not for me.

"[hey seri|ok google|alexa], what day does April 8th fall on?"

The 4-6-8-... and 9-5-7-11 rules are really nice to have on hand. The rest of relating years; 99% of the time I'm going to be calculating dates for the current year so those seem less useful to me (not to mention that part is a lot more complicated to remember)

This is how I do it: https://incubaid.wordpress.com/category/algorithms/

> There are actually 52 (or 53) other days which are all on the same day of the week as "the" Doomsday at the end of February

That seems incorrect, there should always be 51 other days

Doesn't Zellers' Congruence do the same task? Zellers' has been around since 1883, and has been very widely implemented.

Here's a summary of the methods I know for computing the factor based on the last two digits of the year that gets added to the factor from the century number to get the Doomsday for the year.

Notation: "A // B" is integer vision (think Python 3 // operator). "A, B = C /% D" means that "A = C//D" and "B = C % D". "A ≡ B" means A and B are the same mod 7. "A ≡⁴ B" means A and B are the same mod 4. I'll use x for multiplication. X + <a,b,c,d> means the four values A+a, X+b, X+c, X+d.

Let Y be the last two digits of the year.

Observation: 365 ≡ 1. If it weren't for leap years, the year factor would simply go up by 1 each year. A leap year pushes the start of the next year back a day, and that's cumulative, so we need a correction of the number of leap years that have past.

1. That gives the first, and simplest, way to compute the year factor for year Y.

  return Y + Y//4

Advantage: simplest algorithm.

Disadvantage: numbers get larger than you might be comfortable with for fast mental meth. Doing 99, for example, gives 99 + 99/4 = 99 + 24 = 123 ≡ 4, which has plenty of opportunity along the way to goof.

Many people will do better with a method that uses a little more complicated algorithm but cuts down the size of the numbers.

2. The divide by 12 method, which is the one given in the article, does this.

  a, b = Y /% 12
  c = b // 4
  return a + b + c

Here's why it works.

  Y = 12 a + b
  Y//4 = 3 a + b//4
       = 3 a + c
  Y + Y//4 = 15 a + b + c
           ≡ a + b + c

Advantage: a <= 8, b < 12, c < 4. Other than the first /%, you only deal with fairly small numbers.

Disadvantage: Still easy for many people to goof on the initial /%.

Note: if you divide by 20 instead of 12, you get a similar method, except that you'll need to use 4a instead of a. Since a is at most 4, 4a is not large. For many people %/ 20 might be sufficiently easier to deal with in mental math than %/ 12 that it is worth the cost of having to multiply by 4.

3. The odd 11 method.

  Y += 11 if Y is odd
  Y //= 2
  Y += 11 if Y is odd
  return -Y

The easiest way to see that this works is to go back to Y + Y//4. Write Y = 4q + r, where r = 0, 1, 2, or 3.

The first conditional add 11 step turns 4q + <0,1,2,3> into 4q + <0,12,2,14>. Dividing by 2 then gives 2q + <0,6,1,7>. The second conditional add 11 gives 2q + <0,6,12,18>. Negating mod 7 gives 5q + <0,1,2,3>, which is 4q + <0,1,2,3> + q = Y + Y//4.

Similar considerations give other divide by 2 and negate methods. If you note that if Y = 4q, then Y + Y//4 ≡ -(Y//2), then it is just a matter of how to take into account the r in 4q + r when r != 0. One way to do that would be first subtract r, then do the -(Y//2), and then add r back. That works because none of the r != 0 years are leap years, and so we just need to add 1 for each of them.

Another way would be to just go ahead and do -(Y//2), and then add in a correction based on r. Let Y = 4q + <0,1,2,3>. Then -(Y//2) ≡ 5q + <0,0,-1,-1>. We want 5q + <0,1,2,3>, so we have to add 0, 1, 3, or 4 if r = 0, 1, 2, 3, respectively.

That last correction can be split into two parts: add 1 if Y is odd, plus add 2 if Y//2 is odd. That gives:

  t = Y odd ? 1 : 0
  Y //= 2
  t += 3 if Y is odd
  return -Y + t

4. The method I actually use, which views the two digit year as a decade part and a year within the decade part, and operates on them separately. Since I gave a long description of it yesterday, I'll just link to that [1] here.

[1] https://news.ycombinator.com/item?id=21926543

this is a great article went through it and can do it now

It's a nice article and a good algorithm, kudos to all who can do this.

My philosophy however is that I don't need to learn this kind of stuff nowadays. There are computers even in our wrist, so I offload as much as I can, and spare my brain cycles more important stuff that matters.