以数学方式从unix-timestamp计算日期数？

Question

如何从unix-timestamp中以数学方式计算日期数,而不使用任何函数和简单的数学公式.

1313905026 - > 8(今天08/21/2011)

Answer 1

一个UNIX时间戳不包括闰秒,所以我们不必担心.这是一个无分支¹,无循环算法,用于从unix时间戳获取y/m/d字段:

#include <iostream>

int
main()
{
    int s = 1313905026;
    int z = s / 86400 + 719468;
    int era = (z >= 0 ? z : z - 146096) / 146097;
    unsigned doe = static_cast<unsigned>(z - era * 146097);
    unsigned yoe = (doe - doe/1460 + doe/36524 - doe/146096) / 365;
    int y = static_cast<int>(yoe) + era * 400;
    unsigned doy = doe - (365*yoe + yoe/4 - yoe/100);
    unsigned mp = (5*doy + 2)/153;
    unsigned d = doy - (153*mp+2)/5 + 1;
    unsigned m = mp + (mp < 10 ? 3 : -9);
    y += (m <= 2);
    std::cout << m << '/' << d << '/' << y << '\n'; // 8/21/2011
}

这输出:

8/21/2011

由于您不感兴趣y并且m(仅在d),您可以从上面的计算中消除最后几行.

这里以极其详细的方式描述了该算法.该链接包括一个完整的派生,以及跨越数百万年的单元测试(这是过度杀伤).

¹ Branch-less:上面算法中的小分支看起来像是在macOS上的-O3处进行了优化:

__Z14get_day_numberi:                   ## @_Z14get_day_numberi
    .cfi_startproc
## BB#0:
    pushq   %rbp
Ltmp0:
    .cfi_def_cfa_offset 16
Ltmp1:
    .cfi_offset %rbp, -16
    movq    %rsp, %rbp
Ltmp2:
    .cfi_def_cfa_register %rbp
    movslq  %edi, %rax
    imulq   $-1037155065, %rax, %rcx ## imm = 0xFFFFFFFFC22E4507
    shrq    $32, %rcx
    addl    %ecx, %eax
    movl    %eax, %ecx
    shrl    $31, %ecx
    sarl    $16, %eax
    leal    (%rax,%rcx), %edx
    leal    719468(%rax,%rcx), %esi
    testl   %esi, %esi
    leal    573372(%rax,%rcx), %eax
    cmovnsl %esi, %eax
    cltq
    imulq   $963315389, %rax, %rcx  ## imm = 0x396B06BD
    movq    %rcx, %rsi
    shrq    $63, %rsi
    shrq    $32, %rcx
    sarl    $15, %ecx
    addl    %esi, %ecx
    imull   $146097, %ecx, %ecx     ## imm = 0x23AB1
    movl    %eax, %esi
    subl    %ecx, %esi
    subl    %eax, %esi
    leal    719468(%rsi,%rdx), %eax
    movl    %eax, %ecx
    shrl    $2, %ecx
    imulq   $1506180313, %rcx, %rdx ## imm = 0x59C67CD9
    shrq    $39, %rdx
    movl    %eax, %esi
    subl    %edx, %esi
    imulq   $963321983, %rcx, %rcx  ## imm = 0x396B207F
    shrq    $43, %rcx
    addl    %esi, %ecx
    movl    %eax, %edx
    shrl    $4, %edx
    imulq   $7525953, %rdx, %rdx    ## imm = 0x72D641
    shrq    $36, %rdx
    subl    %edx, %ecx
    imulq   $1729753953, %rcx, %rsi ## imm = 0x6719F361
    shrq    $32, %rsi
    movl    %ecx, %r8d
    subl    %ecx, %eax
    movl    %ecx, %edi
    movl    $3855821599, %edx       ## imm = 0xE5D32B1F
    imulq   %rcx, %rdx
    subl    %esi, %ecx
    shrl    %ecx
    addl    %esi, %ecx
    shrl    $8, %ecx
    imull   $365, %ecx, %ecx        ## imm = 0x16D
    subl    %ecx, %r8d
    shrl    $2, %edi
    imulq   $1506180313, %rdi, %rcx ## imm = 0x59C67CD9
    shrq    $39, %rcx
    shrq    $47, %rdx
    addl    %r8d, %eax
    subl    %ecx, %eax
    leal    (%rax,%rdx), %ecx
    leal    2(%rcx,%rcx,4), %esi
    movl    $3593175255, %edi       ## imm = 0xD62B80D7
    imulq   %rsi, %rdi
    shrq    $39, %rdi
    imull   $153, %edi, %edi
    subl    %edi, %esi
    leal    4(%rcx,%rcx,4), %ecx
    subl    %esi, %ecx
    movl    $3435973837, %esi       ## imm = 0xCCCCCCCD
    imulq   %rcx, %rsi
    shrq    $34, %rsi
    leal    1(%rax,%rdx), %eax
    subl    %esi, %eax
    popq    %rbp
    retq
    .cfi_endproc

Answer 2

t = unix time
second = t MOD 60  
minute = INT(t / 60) MOD 60  
hour = INT(t / 60 / 60) MOD 24  
days = INT(t / 60 / 60 / 24)  
years = INT(days / 365.25)  
year = 1970 + years + 1

1970 年以星期四开始，因此我们可以计算星期几：

weekday = (days + 4) MOD 7

如果星期日是第 0 天。如果您希望星期日是第 1 天，只需添加 1。

现在，让我们看看今年已经有多少天了。

days = days - years * 365 - leapdays

最后，我们找到月份和月份的日期。

IF year MOD 4 = 0 THEN ly = 1 ELSE ly = 0
WHILE month <= 12
    month = month + 1
    IF month = 2 THEN
        DaysInMonth = 28 + NOT(year MOD 4) + NOT(year MOD 100)
            + NOT(year MOD 400)
    ELSE
        DaysInMonth = 30 + (month + (month < 7)) MOD 2
    END IF
    IF days > DaysInMonth THEN days = days - DaysInMonth
END WHILE

假设布尔值 TRUE = 1、FALSE = 0、NOT TRUE = 0 和 NOT FALSE = 1。

现在我们有了年、月、月中的日、时、分、秒，并根据闰年进行了调整。

Answer 3

没有简单的公式可以做到这一点。您需要减去自纪元以来的年数（考虑闰年），这可能需要循环或某种离散计算。然后使用某种类型的循环减去当年每个月的秒数。您剩下的是该月当前的秒数。

我会做这样的事情。

x = ...//the number of seconds
year = 1970

while (x > /*one year*/){
 x = x - /*seconds in january, and march-december*/
 if(year % 4 == 0){
  x -= /*leapeay seconds in february*/
 }else{
  x -= /*regular seconds in february*/
 }
}

//Then something like this:

if(x > /*seconds in january*/){
 x -= /*seconds in january*/
}
if(x > /*seconds in february*/){
 x -= /*seconds in january*/
}

.
.
.

//After that just get the number of days from x seconds and you're set.

编辑

为了简单起见，我建议使用日期函数，但如果有人需要它，或者愿意进一步开发它，这里有一个可能的非循环替代答案。

首先让 t 为自纪元以来的当前时间（以秒为单位）。

设 F 为四年中的秒数。即三年平年和一年闰年。那应该是：126230400。

现在如果你去掉F贡献的所有时间，你将得到余数：y。

所以 y = n % F。

现在有几种情况： 1. y 小于一年 2. y 小于两年 3. y 小于三年且小于两个月 4. y 小于三年且大于两个月 5. y 小于四年

请注意，1972 年是闰年，因此如果从 1970 年开始数到四，则从上次开始算起的位置将是两年后的闰年。

让 jan、feb、febLY、mar、may、...、dec 为每个月的秒数（您需要计算出来）。

d 代表当月的天数，D 代表一天的秒数 (86400)。y 表示平年的秒数，yLY 表示闰年的秒数。

y = (t % F)
if(y < Y){
 if(y > jan){
  y -= jan
 }
 if(y > feb){
  y -= feb
 }
 .
 .
 .
 d = y % D
}
else if(y < 2 * y){
 y = y - Y
 if(y > jan){
  y -= jan
 }
 if(y > feb){
  y -= feb
 }
 .
 .
 .
 d = y % D
}
else if(y < 2 * y + yLY){
 y = y - 2 * Y
 if(y > jan){
  y -= jan
 }
 if(y > febLY){
  y -= febLY
 }
 .
 .
 .
 d = y % D
}
else{
 y = y - 2 * Y - yLY
 if(y > jan){
  y -= jan
 }
 if(y > feb){
  y -= feb
 }
 .
 .
 .
 d = y % D
}

未测试。此外，由于地球并非每 24 小时自转一圈，他们偶尔也会对时间进行调整。你需要做一些研究来考虑这一点。