A Formula for the Number of Days in Each Month

[1] http://en.wikipedia.org/wiki/M%C3%B6bius_function [2] http://www.wolframalpha.com/input/?i=30+-+%CE%BC%28n%2B192%2... [3] http://en.wikipedia.org/wiki/Mertens_conjecture

Zeller's Congruence is an algorithm. This is a formula. It made it to the front page because it was a clever hack and people like me love those.

Zeller's Congruence is quite a bit harder to do in your head.

For mental calculation of day of week, I use a method given in a Martin Gardner book, but this only works for 1900-1999. I'll give a fix to extend it to other centuries.

Let Y be the last two digits of the year, let M be the month (1-12), and D be the day of the month (1-31). Let [X] denote the integer part of X.

Compute w = [Y/12] + Y%12 + [Y%12/4]

Compute w = w + month_offset(M), where month_offset is defined by this table:

    M   month_offset
    1     1
    2     4
    3     4
    4     0
    5     2
    6     5
    7     0
    8     3
    9     6
   10     1
   11     4
   12     6

w%7 gives the day of the week, with Saturday being day 0. A couple notes.

1. You can reduce mod 7 as you go. For example, to get the day of the week of 1969-07-16, you could think "[69/12] = 5, add 9 (69%12) giving 14 == 0 mod 7. [9/4] = 2, so we are at 2. Add month_offset(7) == 0, giving 0. Add 16 (D), and we have 3 mod 7, so Wednesday".

2. Month_offset is easy to remember if you think of it this way:

   1 4 4

   0 2 5

   0 3 6

   1 4 6

3. If the year is a leap year, subtract 1 for dates in January and February.

4. For years in 2000-2099, subtract 1 from the result. For years in 1800-1899, add 2. If you forget what the century correction is, you can work it out in your head. For instance, to find the correction for 20xx, work out the day of week of 1999-12-31: 99=12x8+3, [3/4]=0, month_offset(12)=6, so 8+3+0+6+31==6 mod 7, or Friday. Now work out 2000-01-01 without a century correction: 0=0x12+0, [0/4]=0, month_offset(1)=1. 2000 is a leap year, so need to subtract 1 in January, so we have 0+0+0+0+1-1+1==1 mod 7, so Sunday. However, it should be Saturday since it comes after Friday, and so the century correction must be -1 for 20xx.

5. Gardner's method is really one of the other well known methods (I forget which one) adjusted to make mental calculation easier.

Addendum: this is described in chapter 7, "Tricks of Lightning Calculators" from the Martin Gardner collection "Mathematical Carnival".

    Thirty days hath September,
    April, June, and November
    And all the rest have thirty-one
    excepting February alone
    And that has twenty-eight days clear
    and twenty-nine in each leap year

On the due date, someone came into class saying "I could show that the series was increasing and bounded above, and therefore converged to a real number, but I didn't know how to show that the limit of the series was, quote, very special." :D

It gives you one less thing to remember, since you don't have to remember to repeat on the last knuckle.

The knuckle method seems to me to be the "simple" way to count cows--just count the legs and divide by four.

Thirty Days hath December,

March, July and November,

All the rest have 31

Except January.

Admittedly rounding is still cheating but it allows compacter solutions than being spot-on every time. Handling February is left as an exercise for the reader.

Agreed. Using floor it seems like you can construct a function that's effectively defined piecewise, by constructing a floor expression that's zero outside of a specified input domain, and 1 within the domain. Then you multiply the floor expression by the piecewise expression that you'd use to define a piecewise function over that domain.

Nevertheless I found the article to be an interesting read on mathematical reasoning - a thought process for designing functions with particular behavior. Is there a rigorous way of describing why mod and floor seem like cheating in a way, aside from the fact that they can be used to construct piecewise functions? Is the ideal hack in this scenario a continuous, smooth function? (And something more interesting than the result of polynomial interpolation?)

    28+((0x3bbeecc>>(m*2))&3)

    30+(m&1^m>7)-m*(m==2)

  // 28 + ((0x3bbeecc>>m>>m)&3);
  b8 cc ee bb 03    mov  eax,0x3bbeecc
  d3 f8             sar  eax,cl
  d3 f8             sar  eax,cl
  83 e0 03          and  eax,0x3
  83 c0 1c          add  eax,0x1c

I'm not sure this post is meant to be a model for good implementation advice, though, performance-oriented or otherwise. Just an interesting tidbit.

EDIT: I'm trying to figure out how to write code using registers instead of indexes into memory and it ends up with lots of conditionals instead of basically one instruction. The conversation about speed is... tricky. Can some people who are more expert help out?

    days y m = 28 + (m + (m `div` 8)) `mod` 2 + 2 `mod` m + 2 * (1 `div` m) 
               + ((2 `div` m) `mod` 2) * (leap y)
      where leap y = multiple 4 y - multiple 100 y + multiple 400 y
              where multiple int y = ((y + (int - 1)) `mod` int + 1) `div` int

    function f(x) { return 28 + maybeLeap(x) + (...); }

function days2(i) { return (i ^ (i >> 3) | 30) - 1 / (i * 9 % 17) * 2 }

1 30.77777777777778 2 28 3 30.8 4 29 5 30.818181818181817 6 29.333333333333332 7 30.833333333333332 8 30.5 9 29.846153846153847 10 30.6 11 29.857142857142858 12 30.666666666666668

> Why is it any better/faster than a simple switch case like this in Clojure

It's not about better or faster. It's fun to think of things like this. :)

The OP didn't claim it was better than anything, it's just a nice exercise in style!