精华内容
下载资源
问答
  • 日期 Date var week_day = CultureInfo.CurrentCulture.DateTimeFormat.GetDayName(Date.DayOfWeek);

    日期 Date

    var week_day = CultureInfo.CurrentCulture.DateTimeFormat.GetDayName(Date.DayOfWeek);
    
    展开全文
  • C语言根据日期判断星期几(使用基姆拉尔森计算公式)算法如下: 基姆拉尔森计算公式W= (d+2*m+3*(m+1)/5+y+y/4-y/100+y/400) mod 7在公式中d表示日期中的日数,m表示月份数,y表示年数。注意:在公式中有个与其他...
     C语言根据日期判断星期几(使用基姆拉尔森计算公式)
    
    算法如下: 
    基姆拉尔森计算公式
    W= (d+2*m+3*(m+1)/5+y+y/4-y/100+y/400) mod 7

    在公式中d表示日期中的日数,m表示月份数,y表示年数。

    注意:在公式中有个与其他公式不同的地方:

    把一月和二月看成是上一年的十三月和十四月,例:如果是2004-1-10则换算成:2003-13-10来代入公式计算。
    以公元元年为参考,公元元年1月1日为星期一</PRE><PRE>程序如下:

    #include "stdio.h"

    void CaculateWeekDay(int y,int m, int d)
    {
        if(m==1||m==2) {
            m+=12;
            y--;
        }
        int iWeek=(d+2*m+3*(m+1)/5+y+y/4-y/100+y/400)%7;
        switch(iWeek)
        {
        case 0: printf("星期一\n"); break;
        case 1: printf("星期二\n"); break;
        case 2: printf("星期三\n"); break;
        case 3: printf("星期四\n"); break;
        case 4: printf("星期五\n"); break;
        case 5: printf("星期六\n"); break;
        case 6: printf("星期日\n"); break;
        }

    void main()
    {
        int year=0,month=0,day=0;
        printf("请输入日期:\n格式为:1900,1,1\n");
        char temp = '1';
        while (temp != '0')
        {
            scanf("%d,%d,%d",&amp;year,&amp;month,&amp;day);
            scanf("%c",&amp;temp);
            CaculateWeekDay(year,month,day);
            printf("输入0退出,其他继续:");
            scanf("%c",&amp;temp);
        }
    }

    运行效果:
    请输入日期:
    格式为:1900,1,1
    2008,4,29
    星期二
    输入0退出,其他继续:d
    2008,1,1
    星期二
    输入0退出,其他继续:l
    2008,8,8
    星期五
    输入0退出,其他继续:0
    请按任意键继续. . .

    编者注:用来算现在真实日期的星期是没有问题的。原理是根据已知公元1年1月1日的星期数来推算。如果在你的题目中约定了某天是星期几,你要注意那天的星期是否跟真实的星期相同,如果不同,需要考虑相差几天!



    如果大家觉得不够过瘾,可以看看以下该公式的推导过程,让大家对历法有个更深刻的认识

    下面我们完全按自己的思路由简单到复杂一步步进行推导……   
        
      推导之前,先作两项规定:   
      ①用   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日)是不存在的。感兴趣的朋友可以看看这里:   
             
        
              但是我们做的是数字计算,不管那一天是否存在,持续的时间是24小时还是23小时甚至是0小时,只要那个号码存在,就有一个星期与之对应。所以这个公式仍然是适用的。   
              如果要计算的是时间段,就必须考虑这个问题了。
    展开全文
  • 根据日期判断星期几

    2019-03-07 09:34:10
    //基姆拉尔森计算公式根据日期判断星期几 public static String CalculateWeekDay(int y, int m, int d) { if (m == 1 || m == 2) { m += 12; y--; } int iWeek = (d + 2 * ...

        //基姆拉尔森计算公式根据日期判断星期几
        public static String  CalculateWeekDay(int y, int m, int d) {
            if (m == 1 || m == 2) {
                m += 12;
                y--;
            }
            int iWeek = (d + 2 * m + 3 * (m + 1) / 5 + y + y / 4 - y / 100 + y / 400) % 7;
            switch (iWeek) {
                case 0:
                    return "周一";
                case 1:
                    return "周二";
                case 2:
                    return "周三";
                case 3:
                    return "周四";
                case 4:
                    return "周五";
                case 5:
                    return "周六";
                case 6:
                    return "周日";
            }
            return null;
        }

    展开全文
  • //基姆拉尔森计算公式根据日期判断星期几 void CalculateWeekDay(int y, int m,int d){ if(m==1||m==2) m+=12,y--; int iWeek = (d+2*m+3*(m+1)/5+y+y/4-y/100+y/400)%7; switch(iWeek){ case 0: printf("星期...




    //基姆拉尔森计算公式根据日期判断星期几
    void CalculateWeekDay(int y, int m,int d){
    	if(m==1||m==2) m+=12,y--;
    	int iWeek = (d+2*m+3*(m+1)/5+y+y/4-y/100+y/400)%7;
    	switch(iWeek){
    		case 0: printf("星期一\n"); break;
         	case 1: printf("星期二\n"); break;
         	case 2: printf("星期三\n"); break;
         	case 3: printf("星期四\n"); break;
         	case 4: printf("星期五\n"); break;
         	case 5: printf("星期六\n"); break;
         	case 6: printf("星期日\n"); break;
    	}
    }
    int main()
    {
    	CalculateWeekDay(2015,9,17);
    	return 0;
    }




    C语言根据日期判断星期几(使用基姆拉尔森计算公式)

    算法如下:
    基姆拉尔森计算公式
    W= (d+2*m+3*(m+1)/5+y+y/4-y/100+y/400) mod 7

    在公式中d表示日期中的日数,m表示月份数,y表示年数。

    注意:在公式中有个与其他公式不同的地方:

    把一月和二月看成是上一年的十三月和十四月,例:如果是2004-1-10则换算成:2003-13-10来代入公式计算。
    以公元元年为参考,公元元年1月1日为星期一</PRE><PRE>程序如下:

    #include "stdio.h"

    void CaculateWeekDay(int y,int m, int d)
    {
        if(m==1||m==2) {
            m+=12;
            y--;
        }
        int iWeek=(d+2*m+3*(m+1)/5+y+y/4-y/100+y/400)%7;
        switch(iWeek)
        {
        case 0: printf("星期一\n"); break;
        case 1: printf("星期二\n"); break;
        case 2: printf("星期三\n"); break;
        case 3: printf("星期四\n"); break;
        case 4: printf("星期五\n"); break;
        case 5: printf("星期六\n"); break;
        case 6: printf("星期日\n"); break;
        }
    }
    void main()
    {
        int year=0,month=0,day=0;
        printf("请输入日期:\n格式为:1900,1,1\n");
        char temp = '1';
        while (temp != '0')
        {
            scanf("%d,%d,%d",&amp;year,&amp;month,&amp;day);
            scanf("%c",&amp;temp);
            CaculateWeekDay(year,month,day);
            printf("输入0退出,其他继续:");
            scanf("%c",&amp;temp);
        }
    }

    运行效果:
    请输入日期:
    格式为:1900,1,1
    2008,4,29
    星期二
    输入0退出,其他继续:d
    2008,1,1
    星期二
    输入0退出,其他继续:l
    2008,8,8
    星期五
    输入0退出,其他继续:0
    请按任意键继续. . .

    编者注:用来算现在真实日期的星期是没有问题的。原理是根据已知公元1年1月1日的星期数来推算。如果在你的题目中约定了某天是星期几,你要注意那天的星期是否跟真实的星期相同,如果不同,需要考虑相差几天!



    如果大家觉得不够过瘾,可以看看以下该公式的推导过程,让大家对历法有个更深刻的认识

    下面我们完全按自己的思路由简单到复杂一步步进行推导……   
        
      推导之前,先作两项规定:   
      ①用   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日)是不存在的。感兴趣的朋友可以看看这里:   
             
        
              但是我们做的是数字计算,不管那一天是否存在,持续的时间是24小时还是23小时甚至是0小时,只要那个号码存在,就有一个星期与之对应。所以这个公式仍然是适用的。   
              如果要计算的是时间段,就必须考虑这个问题了。
    展开全文
  • C语言根据日期判断星期几

    千次阅读 2017-08-09 09:52:09
    C语言根据日期判断星期几(使用基姆拉尔森计算公式)
  • C语言根据日期判断星期几(使用基姆拉尔森计算公式) 算法如下: 基姆拉尔森计算公式 W= (d+2*m+3*(m+1)/5+y+y/4-y/100+y/400) mod 7 在公式中d表示日期中的日数,m表示月份数,y表示年数。 注意:在公式中有个与...
  • /// 计算指定日期星期值。星期日为0,其他为对应的星期值 /// 默认返回:int类型的星期值 /// </summary> /// <param name="rq"> A System.DateTime</param> public static ...
  • Java实现给定日期计算星期几。通过给定****-**-**的格式来计算星期几
  • javascript根据日期判断星期几

    万次阅读 2011-11-17 17:00:47
    alert( "今天星期 "+"天一二三四五六 ".charAt(new Date(s).getDay())); alert("星期 " + new Date(s).getDay()); !———————————————————————————————————————— 刚...
  • C语言根据日期判断星期几(使用基姆拉尔森计算公式) 算法如下: 基姆拉尔森计算公式 W= (d+2*m+3*(m+1)/5+y+y/4-y/100+y/400) mod 7 在公式中d表示日期中的日数,m表示月份数,y表示年数。 注意:在公式中有...
  • java根据日期获取当前是星期几

    千次阅读 2020-12-01 21:02:51
    * 根据日期获取当前是星期几 */ public static void main(String[] args) throws ParseException { String dates = "2020-12-1"; Calendar cal = Calendar.getInstance(); SimpleDateFormat f = new ...
  • js根据日期计算星期几

    千次阅读 2019-04-28 16:05:28
    function weekDay(date){ var dt = new Date(date.split("-")[0], date.split("-")[1]-1,date = date.... var weekDay = ["星期天", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"]; return weekD...
  • js根据日期判断当天是星期几

    千次阅读 2018-09-11 13:27:15
    星期天", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"]; console.log("打印数值---",dt.getDay()); console.log(&...
  • 设计函数实现输入日期显示星期几。下面为程序的代码:/************************************************************Copyright(C),1988-1999,HuaweiTech.Co.,Ltd.FileName:main.cppAuthor:LightVersion:1.0Date:...
  • java判断输入日期星期几

    千次阅读 2018-08-14 16:41:31
    从页面输入日期判断这个日期星期几,并根据结果进行判断进行不同的操作。   public String getWeek() { Date date = DateUtil.toDate(this.queryDate, "yyyy-MM-dd"); SimpleDateFormat sdf =...
  • JS利用日期判断星期几

    千次阅读 2018-01-18 08:19:38
    function getMyDay(date){var week;if(date.getDay()==0) week="周日"if(date.getDay()==1) week="周一"if(date.getDay()==2) week="周二"if(date.getDay()==3) week="周三"if(date.getDay()==4) week="周四"if(date...
  • JS根据日期得出星期几

    千次阅读 2020-06-30 15:18:44
    function getweekday(date){ var weekArray = new Array(“日”, “一”, “二”, “三”, “四”, “五”...1、获取系统时间并得出星期 var week = weekArray[new Date().getDay()]; 2、根据给定例如 var da = ‘2017-
  • 使用mysql判断日期星期几

    千次阅读 2019-07-17 16:19:29
    SELECT DAYOFWEEK('2019-07-17'); 返回的结果对应 2 ——> 星期一 3 ——> 星期二 4 ——> 星期三 5 ——> 星期四 6 ——> 星期五 7 ——> 星期六 1 ——> 星期日 ...
  • Java 根据日期计算星期几

    万次阅读 2017-02-04 18:00:15
    import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; public class DateTools { ... * 日期星期 * * @param datetime
  • 知识补充:SimpleDateFormat是一个特别敏感的方式格式化和分析...parse方法:将字符串类型(java.lang.String)解析为日期类型(java.util.Date)。学习视频分享:java视频教程示例如下:import java.text.ParseExcep...
  • java 根据日期计算星期几

    千次阅读 2017-08-24 11:21:05
    //一星期的第天 GregorianCalendar.get(GregorianCalendar.Day_OF_MONTH); //一月的第天   注意: GregorianCalendar是在java.util包里. import java.util.*; public class Main { public...
  • 根据输入日期进行利用正则表达式判断日期格式是否正确。若正确判断星期几,若不正确输出格式错误。
  • 不知道大家有没有遇到过同样的问题...每年都要遇到好几次,所以想索性利用Java写个小工具,一次查询某具体日期在n年中分别是星期几。这样不就方便了吗?本文里给出了详细的示例代码,感兴趣的朋友们下面来一起看看吧。
  • 主要介绍了jQuery简单实现根据日期计算星期几的方法,涉及jQuery针对日期时间简单计算相关操作技巧,需要的朋友可以参考下
  • java如何判断给定的日期星期几

    万次阅读 2018-12-31 12:03:56
    import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; /* ... 星期日=星期7 此处根据需要灵活改动即可 */ public void g...
  • 方法 getWeekDay(date){ var week; if(date.getDay()==0) week="周日" if(date.getDay()==1) week="周一" ... if(date.getDay()==2) week="周二" ... if(date.getDay()==3) week="周三" ...
  • 当前日期 import datetime today = datetime.datetime.now().weekday() + 1 # 一定要加1 print(today) 执行输出:5 指定日期 import datetime week = datetime.datetime.strptime("2020801", "%Y%m%d").weekday() +...
  • Python如何根据日期判断周几

    千次阅读 2020-08-08 16:43:00
    业务有一个需求,需要根据日期判断周几。 二、代码 当前日期 import datetime today = datetime.datetime.now().weekday() + 1 print(today) 执行输出:5 指定日期 import datetime week = datetime.datetime...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 56,507
精华内容 22,602
关键字:

根据日期判断星期几