根据日期计算星期几----蔡勒（Zeller）公式推导

计算给定日期是星期几，好象是编程都会遇到的问题，最近论坛里也有人提到这个问题，并给出了一个公式：   
          W=   (d+2*m+3*(m+1)/5+y+y/4-y/100+y/400)   mod   7   
(要求将1、2月当作上一年的13、14月来计算)   
    
去看了看这个公式的原帖
http://blog.csdn.net/ycrao/archive/2000/11/24/3825.aspx   
其讲述的过程并不清楚，便想怎样自己推导出一个公式来，花了几个小时，总算是弄出来了，结果跟上面的公式一样：)   
==============================================================================================

0. 本文的初衷及蔡勒公式的用处

前一段时间，我在准备北邮计算机考研复试的时候，做了几道与日期计算相关的题目，在这个过程中我接触到了蔡勒公式。先简单的介绍一下蔡勒公式是干什么用的。

我们有时候会遇到这样的问题：看到一个日期想知道这一天是星期几，甚至看到一个历史日期或纪念日，我们想快速的知道这一天是星期几。对于这个问题，如果用编程的方式，应该怎么实现呢？你可能已经有思路了，比如你知道某个日期是星期几，把这个日期作为原点，然后计算目标日期和这个原点之间相差多少天，再除以 7 求余数，最后通过余数判断目标日期的星期数。通过这样的过程，你确实可以得到正确的结果，但这不够快速也不够优雅。对于这个问题，如果你懂得蔡勒公式，那就变得异常简单了，你只需要将年月日等数据代入公式，然后计算出结果，这一结果就是目标日期对应的星期数。

当我知道蔡勒公式之后，我觉得它非常有趣也很酷，所以我不仅希望掌握公式的使用，也希望可以掌握公式背后的推导过程。然而，当我在网上搜索相关的文章时，我发现几乎所有向我展示的博客（从零几年到最近的 19 年）大多是转载、复制于这篇文章（链接）：

星期制度是一种有古老传统的制度。据说因为《圣经·创世纪》中规定上帝用了六天时间创世纪，第七天休息，所以人们也就以七天为一个周期来安排自己的工作和生活，而星期日是休息日……

这篇文章质量很不错，讲解过程自然流畅，但是在一些细节上存在错误，有些推导步骤让人感到困惑。因此，当我掌握蔡勒公式后，很希望可以将我的理解输出出来，让想要学习蔡勒公式推导过程的人看到一些新的材料。好了，废话少说，我们开始吧。

1. 蔡勒公式的形式

如果你对公式的推导过程不感兴趣，只是希望使用蔡勒公式，那么只看此小节即可。蔡勒公式的形式如下：

DW=[c4]−2c+y+[y4]+[13(m+1)5]+d−1=Dmod7D=[c4]−2c+y+[y4]+[13(m+1)5]+d−1W=Dmod7

其中：

  • W 是星期数。
  • c 是世纪数减一，也就是年份的前两位。
  • y 是年份的后两位。
  • m 是月份。m 的取值范围是 3 至 14，因为某年的 1、2 月要看作上一年的 13、14月，比如 2019 年的 1 月 1 日要看作 2018 年的 13 月 1 日来计算。
  • d 是日数。
  • [] 是取整运算。
  • mod 是求余运算。

注意：这些符号在后面的推导中还会使用。举一个实际的计算例子：计算 1994 年 12 月 13 日是星期几。显然 c = 19，y = 94，m = 12，d = 13，带入公式：

DW=[194]−2×19+94+[944]+[13×(12+1)5]+13−1=4−38+94+23+33+13−1=128=128mod7=2D=[194]−2×19+94+[944]+[13×(12+1)5]+13−1=4−38+94+23+33+13−1=128W=128mod7=2


由此可得 1994 年 12 月 13 日是星期二，通过查询日历可以验证正确性。

最后关于蔡勒公式，还需要做两点补充说明：

  1. 在计算机编程中，W 的计算结果有可能是负数。我们需要注意，数学中的求余运算和编程中的求余运算不是完全相同的，数学上余数不能是负数，而编程中余数可以是负数。因此，在计算机中 W 是负数时，我们需要进行修正。修正方法十分简单：让 W 加上一个足够大的 7 的整数倍，使其成为正数，得到的结果再对 7 取余即可。比如 -15，我可以让其加上 70，得到 55，再除以 7 余 6，通过余数可知这一天是星期六。
  2. 此公式只适用于格里高利历（也就是现在的公历）。关于历法的问题，大家有兴趣可以自行查阅。

下面是公式的推导。

2. 推导过程

推导蔡勒公式之前，我们先思考一下，如果我们不知道这一公式，我们如何将一个日期转化为星期数呢？

我们可能会很自然地想到：先找到一个知道是星期几的日子，把这个日期作为“原点”，然后计算目标日期和这个原点相差几天，将相差的天数对 7 取余，再根据余数判断星期数。举一个实际例子，比如我们知道 2019 年 5 月 1 日是星期三，把这一天当作原点，现在我们想知道 2019 年 5 月 17 日是星期几，显然这两个日期之间相差 16 天，用 16 除 7 余 2，因为原点是星期三，加上作为偏移量的余数 2，可知 2019 年 5 月 17 日是星期五。

从这个思路出发，经过优化扩展，我们就可以得到神奇的蔡勒公式了。首先，如果我们仔细观察一下可以发现，这个思路中比较麻烦的是计算相差天数（设为 DD ），我们可以把 DD 的计算过程分解成三部分：

  1. D1D1 ：从原点到原点所在年份末尾的天数。
  2. D2D2 ：原点所在年份和目标日期所在年份之间所有年份的天数和。
  3. D3D3 ：目标日期所在年份的第一天到目标日期的天数。

显然，D=D1+D2+D3D=D1+D2+D3 。如果我们把原点选择在某一年的 12 月 31 日，那么就可以省去 D1D1 的计算了，因为原点恰好就是所在年份的最后一天。现在，D=D2+D3D=D2+D3 。

我们再去观察上述思路中的实际例子，可以发现，因为原点是星期三，所以得到余数后，我们需要加上 3 才是正确的星期数。这启示我们可以把原点选定在星期日，这样算出来的余数是几就是星期几（余数 0 代表星期日）。

经过这样的分析。我们希望可以优化原点的日期，使其满足下面两个条件：

  1. 是某一年的 12 月 31 日。
  2. 是星期日。

我们按照现在使用的公历的规则逆推，可以发现公元元年的前一年的 12 月 31 日恰好是星期日，满足我们想要的两个条件，是一个完美的原点。

现在假设目标日期是 y 年 m 月 d 日，我们已经可以很容易的计算 D2D2 了：

D2=(y−1)×365+[y−14]−[y−1100]+[y−1400]D2=(y−1)×365+[y−14]−[y−1100]+[y−1400]


简单的解释一下。因为一年最少有 365 天，所以 D2D2 至少是 (y−1)×365(y−1)×365 。此外，因为闰年比平年多一天，我们还需要加上这些年份中闰年的数量。按照闰年的规则：每 4 年一闰，但每 100 年不闰，每 400 年又闰。可知闰年的数量为 [y−14]−[y−1100]+[y−1400][y−14]−[y−1100]+[y−1400] 。

现在，我们需要得到 D3D3 的计算公式，这块要复杂一些。首先，不考虑闰年的话，每年中 2 月份天数最少，为 28 天。因此，我们不妨把每个月的天数看作 “28 + Excess”的模式，m 月之前所有月份的 Excess 之和为 Accum(m)，则 D3=28×(m−1)+Accum(m)+dD3=28×(m−1)+Accum(m)+d ，并且我们可以得到这样一张表格：

月份123456789101112
天数 31 28 31 30 31 30 31 31 30 31 30 31
Excess 3 0 3 2 3 2 3 3 2 3 2 3
Accum 0 3 3 6 8 11 13 16 19 21 24 26

仔细观察，可以发现 Excess 从 3 月份开始是 3、2、3、2、3 的循环，因此，当 m≥3m≥3 时，Accum(m)Accum(m) 的值的增幅也是 3、2、3、2、3 的循环。因为每 5 个月增加 13，所以把 135135 作为系数；因为 Accum(m)Accum(m) 的值是离散的（都是整数），所以我们用取整运算符，得到：

f(x)=[135x]f(x)=[135x]

我们将 xx 的值取 1，2，3……，然后观察 f(x)f(x) 的值，可得下面这张表格：

x4567891011121314
f(x) 10 13 15 18 20 23 26 28 31 33 36

我们可以发现，当 x≥4x≥4 时，f(x)f(x) 的值的增幅也是 3，2，3，2，3 的循环。也就是说 f(x)f(x) 的值的增幅（x≥4x≥4 ）与 Accum(m)Accum(m) 的值的增幅（m≥3m≥3 ）相同，这意味着 f(x)f(x) 与 Accum(m)Accum(m) 之间相差一个常数，我们随便带入一个具体的值计算：

f(4)−Accum(3)=10−3=7f(4)−Accum(3)=10−3=7


可知相差的常数为 7。由此可得，当 m≥3m≥3 时，Accum(m)Accum(m) 的值的序列，等于当 x≥4x≥4 时，f(x)−7f(x)−7 的值的序列。这样我们就得到了 Accum(m),m≥3Accum(m),m≥3 的函数形式：

Accum(m)=f(m+1)−7=[13(m+1)5]−7Accum(m)=f(m+1)−7=[13(m+1)5]−7

这里多说两句，实际上，Accum(m)Accum(m) 的函数形式是不唯一的，使用其他的构造方法，可以得到形式不同的 Auccm(m)Auccm(m) ，只要符合要求即可。

进一步，我们可以得到 D3D3 的函数形式：

D3=⎧⎩⎨⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪d,31+d,(m−1)×28+[13(m+1)5]−7+d+i,m=1m=2m≥3D3={d,m=131+d,m=2(m−1)×28+[13(m+1)5]−7+d+i,m≥3


其中，平年时，i=0i=0 ；闰年时，i=1i=1 。这还不是 D3D3 最完美的形式。我们继续分析，从 3 月份到 12 月份的 Excess 正好是两个 3、2、3、2、3 的循环，那么假如有第 13 月，想要继续保持这种循环规律，13 月的 Excess 值应该是 3。而 1 月份的 Excess 的值恰好是 3，所以我们不妨变通一下，把每年的 1 月、2月当作上一年的 13月、14 月。这样不仅仍然符合公式，而且 2 月份变成了上一年的最后一个月，也就是公式中 dd 的部分，于是平闰年的影响也去掉了，D3D3 的公式简化成了：

D3=(m−1)×28+[13(m+1)5]−7+d,3≤m≤14D3=(m−1)×28+[13(m+1)5]−7+d,3≤m≤14


现在，我们已经得到了 D2D2 和 D3D3 的计算函数，由 D=D2+D3D=D2+D3 ，可知：

D=(y−1)×365+[y−14]−[y−1100]+[y−1400]+(m−1)×28+[13(m+1)5]−7+d,3≤m≤14D=(y−1)×365+[y−14]−[y−1100]+[y−1400]+(m−1)×28+[13(m+1)5]−7+d,3≤m≤14


注意！这个公式离正确形式还差一小步。因为在当前的公式中，每年的 1 月和 2 月被当作上一年的 13 月和 14 月计算，因此当前公式中计算闰日的部分（[y−14]−[y−1100]+[y−1400][y−14]−[y−1100]+[y−1400] ）存在错误。举一个具体的例子，比如计算公元 4 年（闰年）3 月 1 日的星期数。在当前公式中，公元 4 年的 2 月被算作了公元 3 年的 14 月（换句话说公元 3 年变成了闰年），而公式中计算闰日的部分没有考虑这点，依然将公元 3 年当成平年计算，因此少算了一天。因此，计算闰日的部分应当改进，公式如下：

D=(y−1)×365+[y4]−[y100]+[y400]+(m−1)×28+[13(m+1)5]−7+d,3≤m≤14(1)(1)D=(y−1)×365+[y4]−[y100]+[y400]+(m−1)×28+[13(m+1)5]−7+d,3≤m≤14


计算出 D 的值后，对 7 取模即可得到星期数。

根据同余定理，D 除以 7 所得的余数等于 D 式的各项分别除以 7 所得余数之和（余数之和大于等于 7 时，再对 7 取余），因此可以消去 D 式中能被 7 整除的项，进行化简：

D=(y−1)×365+[y4]−[y100]+[y400]+(m−1)×28+[13(m+1)5]−7+d=(y−1)×(364+1)+[y4]−[y100]+[y400]+[13(m+1)5]+d=(y−1)+[y4]−[y100]+[y400]+[13(m+1)5]+d(2)D=(y−1)×365+[y4]−[y100]+[y400]+(m−1)×28+[13(m+1)5]−7+d=(y−1)×(364+1)+[y4]−[y100]+[y400]+[13(m+1)5]+d(2)=(y−1)+[y4]−[y100]+[y400]+[13(m+1)5]+d


简单说明一下：

(y−1)×365=(y−1)×(364+1)=(y−1)×364+(y−1)=(y−1)×52×7+(y−1)(y−1)×365=(y−1)×(364+1)=(y−1)×364+(y−1)=(y−1)×52×7+(y−1)


显然，结果中的第一项是 7 的倍数，除以 7 余数为 0，因此 (y−1)×365(y−1)×365 除以 7 的余数其实就等于 (y−1)(y−1) 除以 7 的余数，我们只保留 (y−1)(y−1) 就够了。化简过程中，其他被销去的项同理。

公式（2）还不是最简练的形式，我们还可以对年份进行处理。我们现在用公式（2）计算出每个世纪第一年 3 月 1 日的星期数，得到如下结果：

年份：1, 401, 801, … , 2001101, 501, 901, … , 2101201, 601, 1001, … , 2201301, 701, 1101, … ,2301
星期： 4 2 0 5

可以发现，每隔 4 个世纪，星期数就会重复一次。因为在数学上，-2 和 5 除以 7 的余数相同，所以我们不妨把这个重复序列中的 5 改为 -2。这样，4、2、0、-2 恰好构成了一个等差数列。利用等差公式，我们可以得到计算每个世纪第一年的 3 月 1 日星期数的公式：

W=4−2(cmod4)(3)(3)W=4−2(cmod4)


其中，cc 是世纪数减一。我们把公式（2）和公式（3）联立，代入特定的日期——3 月 1 日，可以得到：

((y−1)+[y−14]−[y−1100]+[y−1400]+11)mod7=4−2(cmod4)((y−1)+[y−14]−[y−1100]+[y−1400]+11)mod7=4−2(cmod4)


利用同余定理，经过变换得到:

(y−1)+[y−14]−[y−1100]+[y−1400]≡−2(cmod4)(mod7)(4)(4)(y−1)+[y−14]−[y−1100]+[y−1400]≡−2(cmod4)(mod7)


其中，≡≡ 是表示同余的符号，括号中 mod7mod7 的意思是指 ≡≡ 两边的数除以 7 得到的余数相同。根据公式（4），我们可以知道在每个世纪的第一年，(y−1)+[y−14]−[y−1100]+[y−1400](y−1)+[y−14]−[y−1100]+[y−1400] 可以被 −2(cmod4)−2(cmod4) 同余替换。进而计算 DD 的公式得到如下形式：

D=−2(cmod4)+[13(m+1)5]+d(5)(5)D=−2(cmod4)+[13(m+1)5]+d


注意！现在的计算公式只能适用于每个世纪的第一年。但是，有个这个公式，再加上计算一个世纪中闰日的部分，我们就可以很容易地得到计算这个世纪其他年份的日期的星期数的公式了。令 c 等于世纪数减一，y 等于世纪中的年份数（如 1994 年，则 c = 19，y = 94）。因为一个世纪中只有一百年，所以不用考虑“四百年又闰”的情况；因为每百年，即每个世纪最后一年的 y = 00，而 [y4]y=0=0[y4]y=0=0 ，所以 [y4][y4] 既可以计算四年一闰的情况，又满足百年不闰的要求 。综合这些情况，与得到公式（2）的过程类似，我们可以得到：

D=−2(cmod4)+(y−1)+[y4]+[13(m+1)5]+d(6)(6)D=−2(cmod4)+(y−1)+[y4]+[13(m+1)5]+d


在公式（6）中，yy 是年份的后两位。

最后，我们来把公式中的取模运算改成四则运算。设商为 qq ，余数为 rr ，则：

4q+r=c4q+r=c


又因为，

qr=[c4]=cmod4q=[c4]r=cmod4


可得：

cmod4=c−4×[c4]cmod4=c−4×[c4]


代入公式（6）可得：

D=[c4]−2c+y−1+[y−14]+[13(m+1)5]+d(7)(7)D=[c4]−2c+y−1+[y−14]+[13(m+1)5]+d

至此，我们就得到了蔡勒公式的最终形式。

 

出处：https://www.cnblogs.com/faterazer/p/11393521.html

==============================================================================================
    
  下面我们完全按自己的思路由简单到复杂一步步进行推导……   
    
  推导之前，先作两项规定：   
  ①用   y,   m,   d,   w   分别表示   年   月   日   星期(w=0-6   代表星期日-星期六   
  ②我们从   公元0年1月1日星期日   开始   
    
    
  一、只考虑最开始的   7   天，即   d   =   1---7   变换到   w   =   0---6   
          很直观的得到:   
          w   =   d-1   
    
  二、扩展到整个1月份   
          模7的概念大家都知道了，也没什么好多说的。不过也可以从我们平常用的日历中看出来，在周历里边每列都是一个按7增长的等差数列，如1、8、15、22的星期都是相同的。所以得到整个1月的公式如下：   
          w   =   (d-1)   %   7     ---------   公式⑴   
    
  三、按年扩展   
          由于按月扩展比较麻烦，所以将年扩展放在前面说   
    
          ①   我们不考虑闰年，假设每一年都是   365   天。由于365是7的52倍多1天，所以每一年的第一天和最后一天星期是相同的。   
          也就是说下一年的第一天与上一年的第一天星期滞后一天。这是个重要的结论，每过一年，公式⑴会有一天的误差，由于我们是从0年开始的，所以只须要简单的加上年就可以修正扩展年引起的误差，得到公式如下：   
          w   =   (d-1   +   y)   %   7     
    
          ②   将闰年考虑进去   
          每个闰年会多出一天，会使后面的年份产生一天的误差。如我们要计算2005年1月1日星期几，就要考虑前面的已经过的2004年中有多少个闰年，将这个误差加上就可以正确的计算了。   
          根据闰年的定义(能被4整但不能被100整除或能被400整)，得到计算闰年的个数的算式：y/4   -   y/100   +   y/400。   
          由于我们要计算的是当前要计算的年之前的闰年数，所以要将年减1，得到了如下的公式：   
          w   =   [d-1+y   +   (y-1)/4-(y-1)/100+(y-1)/400]   %   7   -----公式⑵   
    
          现在，我们得到了按年扩展的公式⑵，用这个公式可以计算任一年的1月份的星期   
    
  四、扩展到其它月   
          考虑这个问题颇费了一翻脑筋，后来还是按前面的方法大胆假才找到突破口。   
    
          ①现在我们假设每个月都是28天，且不考虑闰年   
          有了这个假设，计算星期就太简单了，因为28正好是7的整数倍，每个月的星期都是一样的，公式⑵对任一个月都适用   ：)   
    
          ②但假设终究是假设，首先1月就不是28天，这将会造成2月份的计算误差。1月份比28天要多出3天，就是说公式⑵的基础上，2月份的星期应该推后3天。   
          而对3月份来说，推后也是3天(2月正好28天，对3月的计算没有影响)。   
          依此类推，每个月的计算要将前面几个月的累计误差加上。   
          要注意的是误差只影响后面月的计算，因为12月已是最后一个月，所以不用考虑12月的误差天数，同理，1月份的误差天数是0，因为前面没有月份影响它。   
    
          由此，想到建立一个误差表来修正每个月的计算。   
  ==================================================   
  月     误差   累计     模7   
  1       3         0           0   
  2       0         3           3   
  3       3         3           3   
  4       2         6           6   
  5       3         8           1   
  6       2         11          4   
  7       3         13          6   
  8       3         16          2   
  9       2         19          5   
  10      3         21          0   
  11      2         24          3   
  12      -         26          5   
          (闰年时2月会有一天的误差，但我们现在不考虑)   
  ==================================================   
    
          我们将最后的误差表用一个数组存放   
          在公式⑵的基础上可以得到扩展到其它月的公式   
    
          e[]   =   {0,3,3,6,1,4,6,2,5,0,3,5}   
          w   =   [d-1+y   +   e[m-1]   +   (y-1)/4-(y-1)/100+(y-1)/400]   %   7   --公式⑶   
    
          ③上面的误差表我们没有考虑闰年，如果是闰年，2月会一天的误差，会对后面的3-12月的计算产生影响，对此，我们暂时在编程时来修正这种情况，增加的限定条件是如果当年是闰年，且计算的月在2月以后，需要加上一天的误差。大概代码是这样的：   
            
          w   =   (d-1   +   y   +   e[m-1]   +   (y-1)/4   -   (y-1)/100   +   (y-1)/400);   
          if(m>2   &&   (y%4==0   &&   y%100!=0   ||   y%400==0)   &&   y!=0)   
                  ++w;   
          w   %=   7;   
            
          现在，已经可以正确的计算任一天的星期了。   
          注意：0年不是闰年，虽然现在大都不用这个条件，但我们因从公元0年开始计算，所以这个条件是不能少的。   
    
          ④   改进   
          公式⑶中，计算闰年数的子项   (y-1)/4-(y-1)/100+(y-1)/400   没有包含当年，如果将当年包含进去，则实现了如果当年是闰年，w   自动加1。   
          由此带来的影响是如果当年是闰年，1,2月份的计算会多一天误差，我们同样在编程时修正。则代码如下   
            
          w   =   (d-1   +   y   +   e[m-1]   +   y/4   -   y/100   +   y/400);   ----   公式⑷   
          if(m<3   &&   (y%4==0   &&   y%100!=0   ||   y%400==0)   &&   y!=0)   
                  --w;   
          w   %=   7;   
            
          与前一段代码相比，我们简化了   w   的计算部分。   
          实际上还可以进一步将常数   -1   合并到误差表中，但我们暂时先不这样做。   
            
          至此，我们得到了一个阶段性的算法，可以计算任一天的星期了。   
    
  public   class   Week   {   
          public   static   void   main(String[]   args){   
                  int   y   =   2005;   
                  int   m   =   4;   
                  int   d   =   25;   
                    
                  int   e[]   =   new   int[]{0,3,3,6,1,4,6,2,5,0,3,5};   
                  int   w   =   (d-1+e[m-1]+y+(y>>2)-y/100+y/400);   
                  if(m<3   &&   ((y&3)==0   &&   y%100!=0   ||   y%400==0)   &&   y!=0){   
                          --w;   
                  }   
                  w   %=   7;   
                    
                  System.out.println(w);   
          }   
  }
五、简化   
          现在我们推导出了自己的计算星期的算法了，但还不能称之为公式。   
          所谓公式，应该给定年月日后可以手工算出星期几的，但我们现在的算法需要记住一个误差表才能进行计算，所以只能称为一种算法，还不是公式。   
          下面，我们试图消掉这个误差表……   
    
          =============================   
          消除闰年判断的条件表达式   
          =============================   
    
          由于闰年在2月份产生的误差，影响的是后面的月份计算。如果2月是排在一年的最后的话，它就不能对其它月份的计算产生影响了。可能已经有人联想到了文章开头的公式中为什么1,2月转换为上年的13,14月计算了吧   ：)   
    
          就是这个思想了，我们也将1,2月当作上一年的13,14月来看待。   
          由此会产生两个问题需要解决：   
          1>一年的第一天是3月1日了，我们要对   w   的计算公式重新推导   
          2>误差表也发生了变化，需要得新计算   
    
          ①推导   w   计算式   
              1>   用前面的算法算出   0年3月1日是星期3   
                    前7天,   d   =   1---7     ===>     w   =   3----2   
                    得到   w   =   (d+2)   %   7   
                    此式同样适用于整个三月份   
              2>   扩展到每一年的三月份   
                    [d   +   2   +   y   +   (y-1)/4   -   (y-1)/100   +   (y-1)/400]   %   7   
    
          ②误差表   
  ==================================================   
  月     误差   累计     模7   
  3       3         0           0   
  4       2         3           3   
  5       3         5           5   
  6       2         8           1   
  7       3         10          3   
  8       3         13          6   
  9       2         16          2   
  10      3         18          4   
  11      2         21          0   
  12      3         23          2   
  13      3         26          5   
  14      -         29          1   
  ==================================================   
    
          ③得到扩展到其它月的公式   
          e[]   =   {0,3,5,1,3,6,2,4,0,2,5,1}   
          w   =   [d+2   +   e[m-3]   +y+(y-1)/4-(y-1)/100+(y-1)/400]   %   7   
          (3   <=   m   <=   14)   
    
          我们还是将   y-1   的式子进行简化   
          w   =   [d+2   +   e[m-3]   +y+y/4-y/100+y/400]   %   7   
          (3   <=   m   <=   14)   
    
          这个式子如果当年是闰年，会告成多1的误差   
          但我们将1,2月变换到上一年的13,14月，年份要减1，所以这个误差会自动消除，所以得到下面的算法：   
    
          int   e[]   =   new   int[]{0,3,5,1,3,6,2,4,0,2,5,1};   
          if(m   <   3)   {   
                  m   +=   12;   
                  --y;   
          }   
          int   w   =   (d+2   +   e[m-3]   +y+(y/4)-y/100+y/400)   %   7;   -----公式⑸   
    
          我们可以看到公式⑸与公式⑷几乎是一样的，仅仅是误差天和一个常数的差别   
          常数的区别是由起始日期的星期不同引起的，0年1月1日星期日，0年3日1日星期三，有三天的差别，所以常数也从   -1   变成了   2。   
    
          现在，我们成功的消除了繁琐的闰年条件判断。   
    
    
          =============================   
          消除误差表   
          =============================   
          假如存在一种m到e的函数映射关系，使得   
                  e[m-3]   =   f(m)   
          则我们就可以用   f(m)   取代公式⑸中的子项   e[m-3]，也就消除了误差表。   
    
          由于误差表只有12个项，且每一项都可以加减   7n   进行调整，这个函数关系是可以拼凑出来的。但是这个过程可能是极其枯燥无味的，我现在不想自己去推导它，我要利用前人的成果。所谓前人栽树，后人乘凉嘛   ：)   
    
          文章开头开出的公式中的   2*m+3*(m+1)/5   这个子项引起了我的兴趣   
    
          经过多次试试验，我运行下面的代码   
    
          for(m=1;   m<=14;   ++m)   
                  System.out.print((-1+2*m+3*(m+1)/5)%7   +   "   ");   
          System.out.println();   
    
          天哪，输出结果与我的误差表不谋而合，成功了，哈哈   
    
          2   4   0   3   5   1   3   6   2   4   0   2   5   1   
          Press   any   key   to   continue...   
    
          上面就是输出结果，看它后面的12项，与我的误差表完全吻合!!!   
    
          现在就简单的，将   f(m)   =   -1   +   2*m   +   3*(m+1)/5   代入公式⑸，得到   
    
          w   =   (d+1+2*m+3*(m+1)/5+y+(y/4)-y/100+y/400)   %   7   ----公式6   
          约束条件:   m=1,m=2   时   m=m+12,y=y-1;   
    
          现在，我们得到了通用的计算星期的公式，并且“完全”是按自己的思想推导出来的(那个函数映射关系不算)，只要理解了这个推导的步骤，即使有一天忘记了这个公式，也可以重新推导出来!   
    
          可能有人会注意到公式⑹与文章开头的公式相差一个常数   1，这是因为原公式使用数字0--6表示星期一到星期日，而我用0--6表示星期日到星期六。实际上是一样，你可以改成任意你喜欢的表示方法，只需改变这个常数就可以了。   
    
    
  六、验证公式的正确性。   
    
          一个月中的日期是连续的，只要有一天对的，模7的关系就不会错，所以一个月中只须验证一天就可以了，一天需要验12天。由于扩展到年和月只跟是否闰年有关系，就是说至少要验证一个平年和一个闰年，也就是最少得验证24次。   
          我选择了   2005   年和   2008   年，验证每个月的1号。   
  测试代码如下：   
    
  class   test   {   
          public   int   GetWeek(int   y,   int   m,   int   d)   {   
                  if(m<3)   {   
                          m   +=   12;   
                          --y;   
                  }   
                  int   w   =   (d+1+2*m+3*(m+1)/5+y+(y>>2)-y/100+y/400)   %   7;   
                  return   w;   
          }   
  }   
    
  public   class   Week   {   
          public   static   void   main(String[]   args){   
                  int   y   =   2005;   
                  int   m   =   1;   
                  int   d   =   1;   
                    
                  test   t   =   new   test();   
                  String   week[]   =   new   String[]{   
                          "星期日","星期一","星期二","星期三","星期四","星期五","星期六"   
                  };   
                    
                  for(y=2005;   y<=2008;   y+=3)   {   
                          for(m=1;   m<=12;   ++m)   {   
                                  String   str   =   y   +   "-"   +   m   +   "-"   +   d   +   "\t"   +   week[t.GetWeek(y,m,d)];   
                                  System.out.println(str);   
                          }   
                  }   
          }   
  }   
  查万年历，检查程序的输出，完全正确。   
    
  七、后话   
    
          我们这个公式的推导是以0年3月1日为基础的，对该日以后的日期都是可以计算的。但是否可以扩展到公元前(1,2已属于公元前1年的13,14月了)呢？   
    
          虽然我对0年1月和2月、以及公元前1年(令y=-1)的12月作了验证是正确的，但我在推导这个公式时并未想到将其扩展到公元前，所以上面的推导过程没有足够理论依据可以证明其适用于公元前。(负数的取模在不同的编译器如C++中好象处理并不完全正确)。   
    
          另外一有点是对于0年是否存在的争议，一种折中的说法是0年存在，但什么也没有发生，其持续时间为0。还有在罗马的格利戈里历法中有10天是不存的(1582年10月5日至14持续时间为0)，英国的历法中有11天(1752年9月3日至13日)是不存在的。感兴趣的朋友可以看看这里：   
          http://www.whtv.com.cn/zhuanti/celebration/when/wz16.htm   
也可以参考我的blog里的文章：
   http://www.cnblogs.com/mq0036/p/3534186.html
    
          但是我们做的是数字计算，不管那一天是否存在，持续的时间是24小时还是23小时甚至是0小时，只要那个号码存在，就有一个星期与之对应。所以这个公式仍然是适用的。   
          如果要计算的是时间段，就必须考虑这个问题了。

出处：http://wenku.baidu.com/link?url=HUyfxNpxM8m2yC6vyILIlj2ghuAEblyXcY9yum3FFH6B5d-YOINc6yg1k-8LCV46ALHW-2aoShYaJkO-z_ifvRrHNRkdZOqOfeLexCe48NK

posted on 2014-01-26 17:49  jack_Meng  阅读(5842)  评论(0)  编辑  收藏  举报

导航