判断距离1970年1月1日的天数

#include <stdlib.h>

/******************************************************************
功能: 输入年月日,计算距离1970年1月1日的天数

输入:
    年月日,输入年份范围【1970,2100】,输入年月日的有效性需要判断

输出:
     DaysSince1970:距离1970年1月1日的天数
     已知 1970年1月1日为星期四
     异常时,输出不需要关注

返回:
1 上班
0 休假
-1 表示异常

     根据国家规定:周一到周五需要上班。
     根据公司规则:月末周六需要上班。

     注:由于项目紧张,国家规定的节假日如果在周一到周五需要上班^_^。

举例:
    输入:Year = 1970, Month = 1, Day = 3 ,输出 2,返回值为 0 休假

********************************************************************/
#define IS_LEAP_YEAR(y) ((y) / 4 - (y) / 100 + (y) / 400 - (y - 1) / 4 + (y - 1) / 100 - (y - 1) / 400)

int DayNumber[][13] = {{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, {0, 31, 29, 31, 30, 31, 30, 31, 31, 30,
                                                                             31, 30, 31}};
int dayofweek(int y, int m, int d) // 0  =  Sunday
{
    static int t[] = {0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4};

    y -= m < 3;
    return (y + y / 4 - y / 100 + y / 400 + t[m - 1] + d) % 7;
}

int accumulationdayfrom1970(int *DaysSince1970, int Year, int Month, int Day)
{
    *DaysSince1970 = 0;

    for (int i = 1970; i < Year; i++)
    {
        if (IS_LEAP_YEAR(i))
        {
            *DaysSince1970 += 366;
        }
        else
        {
            *DaysSince1970 += 365;
        }
    }

    for (int i = 1; i < Month; i++)
    {
        int xs = IS_LEAP_YEAR(Year);
        *DaysSince1970 += DayNumber[IS_LEAP_YEAR(Year)][i];
    }

    *DaysSince1970 += Day - 1;
    return *DaysSince1970;
}

int GetCurrentDate(int *DaysSince1970, int Year, int Month, int Day)
{
    if (NULL == DaysSince1970)
    {
        return -1;
    }

    if ((Year < 1970) || (Year > 2100))
    {
        return -1;
    }

    if ((Month > 12) || (Month <= 0))
    {
        return -1;
    }

    int IsLeapYear = IS_LEAP_YEAR(Year); // 闰年返回1

    int weekday = dayofweek(Year, Month, Day);

    if ((Day > DayNumber[IsLeapYear][Month]) || (Day <= 0))
    {
        return -1;
    }

    *DaysSince1970 = accumulationdayfrom1970(DaysSince1970, Year, Month, Day);

    if ((0 < weekday) && (weekday < 6))
    {
        return 1;
    }
    else if (0 == weekday)
    {
        return 0;
    }

    if (weekday == 6)
    {
        if (IsLeapYear)
        {
            switch (Month)
            {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                if ((25 <= Day) && (Day <= 31))
                {
                    return 1;
                }
                else
                {
                    return 0;
                }

                break;
            case 4:
            case 6:
            case 9:
            case 11:
                if ((24 <= Day) && (Day <= 30))
                {
                    return 1;
                }
                else
                {
                    return 0;
                }

                break;
            case 2:
                if ((23 <= Day) && (Day <= 29))
                {
                    return 1;
                }
                else
                {
                    return 0;
                }

                break;
            default:
                ;
            }
        }
        else
        {
            switch (Month)
            {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                if ((25 <= Day) && (Day <= 31))
                {
                    return 1;
                }
                else
                {
                    return 0;
                }

                break;
            case 4:
            case 6:
            case 9:
            case 11:
                if ((24 <= Day) && (Day <= 30))
                {
                    return 1;
                }
                else
                {
                    return 0;
                }

                break;
            case 2:
                if ((22 <= Day) && (Day <= 28))
                {
                    return 1;
                }
                else
                {
                    return 0;
                }

                break;
            default:
                ;
            }
        }
    }

    return -1;
}

判断距离1970年1月1日的天数

时间: 2024-11-02 12:19:14

判断距离1970年1月1日的天数的相关文章

2.给出距离1900年1月1日的天数,求日期

1 #include <iostream> 2 #include <assert.h> 3 4 5 //判断是否闰年 6 bool IsLeapYear(unsigned int year) 7 { 8 if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) 9 { 10 return true; 11 } 12 else 13 { 14 return false; 15 } 16 } 17 18 //根

日期类的时间从为什么是从1970年1月1日(格林威治时间)

I suspect that Java was born and raised on a UNIX system.UNIX considers the epoch (when did time begin) to be midnight, January 1, 1970.是说java起源于UNIX系统,而UNIX认为1970年1月1日0点是时间纪元. 但这依然没很好的解释"为什么",出于好奇,继续Google,总算找到了答案: http://en.wikipedia.org/wiki/

为什么编程时间从1970年1月1日開始?

查看原文:http://www.ibloger.net/article/136.html 最初计算机操作系统是32位,而时间也是用32位表示. System.out.println(Integer.MAX_VALUE); 2147483647 Integer在JAVA内用32位表示,因此32位能表示的最大值是2147483647. 另外1年365天的总秒数是31536000, 2147483647/31536000 = 68.1 也就是说32位能表示的最长时间是68年.而实际上到2038年01月

java为啥计算时间从1970年1月1日开始

http://www.myexception.cn/program/1494616.html ---------------------------------------------------------- java为什么计算时间从1970年1月1日开始 今天在看Python  API 时,看到 time 模块 : The epoch is the point where the time starts. On January 1st of that year, at 0 hours,the

为什么编程语言以及数据库要从1970年1月1日开始计算时

今天在看Python  API时,看到time模块: The epoch is the point where the time starts. On January 1st of that year, at 0 hours,the “time since the epoch” is zero. For Unix, the epoch is 1970. To find out what the epoch is, look at gmtime(0). 定义time从1970年1月1日开始,忽然想

Java 获取各时区时间,获取当前时间到格林威治时间1970年01月01日00时00分00秒的秒数

格林威治时间即UTC/GMT时间,1970年01月01日00时00分00秒(即UTC+8的北京时间1970年01月01日08时00分00秒)计算代码如下: 1 /** 2 * 获取指定时间到格林威治时间的秒数 3 * UTC:格林威治时间1970年01月01日00时00分00秒(UTC+8北京时间1970年01月01日08时00分00秒) 4 * @param time 5 * @return 6 */ 7 public static long diffSeconds(String time){

为什么编程时间从1970年1月1日开始?

最初计算机操作系统是32位,而时间也是用32位表示. System.out.println(Integer.MAX_VALUE); 2147483647 Integer在JAVA内用32位表示,因此32位能表示的最大值是2147483647.另外1年365天的总秒数是31536000, 2147483647/31536000 = 68.1 也就是说32位能表示的最长时间是68年,而实际上到2038年01月19日03时14分07秒,便会到达最大时间,过了这个时间点,所有32位操作系统时间便会变为

从1970年1月1日00:00:00 GMT以来此时间对象表示的毫秒数转化为Datetime

将Long类型转换为DateTime类型 /// <summary> /// 将Long类型转换为DateTime类型 /// </summary> /// <param name="d">long</param> /// <returns></returns> public static DateTime ConvertLongDateTime(long ticks) { DateTime dtBase = ne

格林治时间,也就是返回从 UTC 1970 年 1 月 1 日午夜开始经过的毫秒数。

(* Delphi获取13位格林治时间实现方法, 与java中的java.lang.System.currentTimeMillis()效果相同 *) var SysTime: TSystemTime; begin GetSystemTime(SysTime); // 方法1 Memo1.Lines.Add(FormatFloat('#', CompToDouble(TimeStampToMSecs( DateTimeToTimeStamp(SystemTimeToDateTime(SysTim