如何在 C 中以编程方式查找闰年

Question

我用C写了一个程序来判断输入的年份是否是闰年。但不幸的是它运作不佳。它说一年是闰年，上一年不是闰年。

#include <stdio.h>
#include <conio.h>

int yearr(int year);

void main(void) {
    int year;
    printf("Enter a year:");
    scanf("%d", &year);
    if (!yearr(year)) {
        printf("It is a leap year.");
    } else {
        printf("It is not a leap year");
    }

    getch();
}

int yearr(int year) {
    if ((year % 4 == 0) && (year / 4 != 0))
        return 1;
    else
        return 0;
}

阅读评论后，我将代码编辑为：

#include <stdio.h>
#include <conio.h>

int yearr(int year);

void main(void) {
    int year;
    printf("Enter a year:");
    scanf("%d", &year);
    if (!yearr(year)) {
        printf("It is a leap year.");
    } else {
        printf("It is not a leap year");
    }

    getch();
}

int yearr(int year) {
    if (year % 4 == 0) {
        if (year % 400 == 0)
            return 1;
        if (year % 100 == 0)
            return 0; 
    } else
        return 0;
}

Answer 1

最有效的闰年测试：

if ((year & 3) == 0 && ((year % 25) != 0 || (year & 15) == 0))
{
    /* leap year */
}

此代码在 C、C++、C#、Java 和许多其他类似 C 的语言中有效。该代码使用单个 TRUE/FALSE 表达式，该表达式由三个单独的测试组成：

• 第四年测试：year & 3
• 第 100 年测试：年 % 25
• 第 400 年测试：年 & 15

下面是对该代码如何工作的完整讨论，但首先需要讨论维基百科的算法：

维基百科算法无效/不可靠

维基百科已经发布了一个伪代码算法（请参阅：维基百科：闰年 - 算法）一直受到不断的编辑、评论和破坏。

不要实现维基百科算法！

历史最悠久（且效率低下）的维基百科算法如下所示：

if year modulo 400 is 0 then
   is_leap_year
else if year modulo 100 is 0 then
   not_leap_year
else if year modulo 4 is 0 then
   is_leap_year
else
   not_leap_year

上述算法效率低下，因为它总是执行第 400 年和第 100 年的测试，甚至多年这很快就会无法通过“第四年测试”（模 4 测试）——75% 的概率都是如此！通过重新排序算法以首先执行第四年的测试，我们显着加快了速度。

“最高效”伪代码算法

我向维基百科提供了以下算法（不止一次）：

if year is not divisible by 4 then not leap year
else if year is not divisible by 100 then leap year
else if year is divisible by 400 then leap year
else not leap year

这个“最高效”伪代码只是改变了测试的顺序，因此除以 4 需要首先进行测试，然后是不经常发生的测试。由于“年”在 75% 的情况下不会被四整除，因此在四分之三的情况下，算法仅在一次测试后结束。

注意：我曾与多位维基百科编辑进行过斗争，以改进在那里发布的算法，认为许多新手和专业程序员很快就会到达维基百科页面（由于顶级搜索引擎列表）并实现维基百科伪代码没有任何进一步的研究。维基百科编辑否认并删除了我为改进、注释甚至只是对已发布的算法进行脚注所做的每一次尝试。显然，他们认为提高效率是程序员的问题。这可能是真的，但许多程序员太匆忙而无法进行扎实的研究！

“最有效”闰年测试的讨论

用位与代替模：

我已经用按位与运算替换了维基百科算法中的两个模运算。为什么以及如何？

执行模计算需要除法。在对 PC 进行编程时，人们通常不会三思而后行，但在对小型设备中嵌入的 8 位微控制器进行编程时，您可能会发现 CPU 本身无法执行除法功能。在此类 CPU 上，除法是一个艰巨的过程，涉及重复循环、移位和加/减操作，速度非常慢。这是非常需要避免的。

事实证明，可以使用按位与运算交替实现 2 的幂模（参见：维基百科：模运算 - 性能问题):

x % 2^n == x & (2^n - 1)

许多优化编译器会为您将此类模运算转换为按位与，但针对较小和不太流行的 CPU 的不太先进的编译器可能不会。按位与 (Bitwise-AND) 是每个 CPU 上的一条指令。

通过用 & 替换 modulo 4 和 modulo 400 测试3 和 & 15（见下文：“因式分解以减少数学计算”）我们可以确保最快的代码结果，而无需使用慢得多的除法运算。

不存在等于 100 的 2 的幂。因此，我们被迫在第 100 年测试中继续使用模运算，但 100 被 25 取代（见下文）。

因式分解以简化数学：

除了使用按位与来代替模运算之外，您可能会注意到维基百科算法和优化表达式之间的另外两个争议：

• modulo 100 是替换为 modulo 25
• modulo 400 替换为 & 15

第 100 年测试使用模 25 而不是模 100。我们可以这样做，因为 100 因式分解为 2 x 2 x 5 x 5。因为第四年的测试已经检查了 4 的因数，我们可以从 100 中消除该因数，留下 25。这种优化对于几乎每个 CPU 实现来说可能都是微不足道的（因为 100 和 25 都适合 8 位）。

第 400 年测试使用 & 15 相当于模 16。同样，我们可以这样做，因为 400 因式分解为 2 x 2 x 2 x 2 x 5 x 5。我们可以消除通过第 100 年测试检验的 25 因子，留下 16。我们不能进一步减少 16，因为 8 是因子为 200，因此去除更多因子将在第 200 年产生不需要的正值。

400 年优化对于 8 位 CPU 来说非常重要，首先是因为它避免了除法；但更重要的是，因为值 400 是一个 9 位数字，在 8 位 CPU 中处理起来要困难得多。

短路逻辑 AND/OR 运算符：

最后也是最重要的优化是短路逻辑 AND ('&&') 和 OR ('||') 运算符（请参阅：维基百科：短路评估），在大多数类似 C 的语言中实现。短路运算符之所以如此命名，是因为如果左侧的表达式本身决定了运算的结果，那么它们就不会计算右侧的表达式。

例如：如果年份是 2003 年，则 year & 3 == 0 是错误的。逻辑 AND 右侧的测试不可能使结果为真，因此不会评估其他任何内容。

通过首先执行第 4 年测试，只有第 4 年测试（简单的按位与）在四分之三 (75%) 的时间内进行评估。这极大地加快了程序执行速度，特别是因为它避免了 100 年测试所需的除法（模 25 运算）。

关于括号放置的注释

一位评论者认为我的代码中括号放错了位置，并建议围绕逻辑 AND 运算符（而不是围绕逻辑 OR）重新组合子表达式，如下所示：

if (((year & 3) == 0 && (year % 25) != 0) || (year & 15) == 0) { /* LY */ }

以上是不正确的。逻辑 AND 运算符的优先级高于逻辑 OR，无论是否有新括号，都将首先进行计算。逻辑 AND 参数周围的括号无效。这可能会导致人们完全消除子分组：

if ((year & 3) == 0 && (year % 25) != 0 || (year & 15) == 0) { /* LY */ }

但是，在上述两种情况下，逻辑 OR（第 400 年检验）的右侧几乎每次都会进行评估时间（即不能被 4 和 100 整除的年份）。因此，一个有用的优化被错误地消除了。

我原始代码中的括号实现了最优化的解决方案：

if ((year & 3) == 0 && ((year % 25) != 0 || (year & 15) == 0)) { /* LY */ }

这里，逻辑 OR 只计算可被 4 整除的年份（由于短路 AND）。逻辑 OR 的右侧仅计算可被 4 和 100 整除的年份（由于短路 OR）。

C/C++ 程序员注意

C/C++ 程序员可能会觉得这个表达式更加优化：

if (!(year & 3) && ((year % 25) || !(year & 15))) { /* LY */ }

这并没有更加优化！虽然显式的 == 0 和 != 0 测试被删除，但它们变成隐式的并且仍然执行。更糟糕的是，该代码在 C# 等强类型语言中不再有效，其中 year & 3 计算结果为 int，但逻辑 AND (&&)、OR (||) 和 NOT ( !) 运算符需要 bool 参数。

Answer 2

您确定闰年的逻辑是错误的。这应该可以帮助您开始（来自维基百科）：

if year modulo 400 is 0
       then is_leap_year
else if year modulo 100 is 0
       then not_leap_year
else if year modulo 4 is 0
       then is_leap_year
else
       not_leap_year

x modulo y 表示x 除以y 的余数。例如，12 模 5 等于 2。

Answer 3

很多答案都谈到性能。没有显示任何测量值。
gcc 文档中关于 __builtin_expect 的精彩引用说：

众所周知，程序员不善于预测他们的程序的实际执行情况。

大多数实现使用 && 和 || 的短路作为优化工具，并继续为“最佳”的整除性检查规定“正确”的顺序表现。值得一提的是，短路不一定是优化功能。

同意，某些检查可能会给出明确的答案（例如年份不是 4 的倍数）并使后续测试变得无用。此时立即返回似乎是合理的，而不是继续进行不必要的计算。另一方面，早期返回会引入分支，这可能会降低性能。 （请参阅这篇传奇的帖子。）分支错误预测和不必要的计算之间的权衡很难猜测。事实上，它取决于硬件、输入数据、编译器发出的确切汇编指令（可能从一个版本更改为另一个版本）等。

续集将显示在 quick-bench.com。在所有情况下，我们都会测量检查 std::array中存储的每个值是否为闰年所需的时间。这些值是伪随机的，均匀分布在区间 [-400, 399] 内。更准确地说，它们是由以下代码生成的：

auto const years = [](){
  std::uniform_int_distribution<int> uniform_dist(-400, 399);
  std::mt19937 rng;
  std::array<int, 65536> years;
  for (auto& year : years)
    year = uniform_dist(rng);
  return years;
}();

即使可能，我也不用 & 替换 % （例如 year & 3 == 0< /code> 而不是 year % 4 == 0）。我相信编译器（GCC-9.2 at -O3）会为我做到这一点。 （确实如此。）

4-100-400 次测试

闰年检查通常以三个整除性测试的形式编写：year % 4 == 0、year % 100 != 0 和年份 % 400 == 0。以下是涵盖这些检查可能出现的所有可能顺序的实现列表。每个实现都以相应的标签为前缀。 （有些命令允许两种不同的实现，在这种情况下，第二个获得后缀b。）它们是：

b4_100_400  : year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)
b4_100_400b : (year % 4 == 0 && year % 100 != 0) || year % 400 == 0
b4_400_100  : year % 4 == 0 && (year % 400 == 0 || year % 100 != 0)
b100_4_400  : (year % 100 != 0 && year % 4 == 0) || year % 400 == 0
b100_400_4  : (year % 100 != 0 || year % 400 == 0) && year % 4 == 0
b400_4_100  : year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)
b400_100_4  : year % 400 == 0 || (year % 100 != 0 && year % 4 == 0)
b400_100_4b : (year % 400 == 0 || year % 100 != 0) && year % 4 == 0

结果如下所示。 （查看他们现场。）

与许多人的建议相反，检查首先被 4 整除似乎并不是最好的选择。相反，至少在这些测量中，前三个柱属于最差的五个柱。最好的是

b100_400_4  : (year % 100 != 0 || year % 400 == 0) && year % 4 == 0

4-25-16 次测试

另一个提供的提示（我必须承认我认为这是一个很好的提示）是将 year % 100 != 0 替换为 year % 25 != 0< /代码>。这不会影响正确性，因为我们还会检查year % 4 == 0。 （如果数字是 4 的倍数，则被 100 整除相当于被 25 整除。）同样，year % 400 =由于存在 25 的整除性检查，因此 = 0 可以替换为 year % 16 == 0。

与上一节一样，我们有 8 个使用 4-25-16 整除性检查的实现：

b4_25_16  : year % 4 == 0 && (year % 25 != 0 || year % 16 == 0)
b4_25_16b : (year % 4 == 0 && year % 25 != 0) || year % 16 == 0
b4_16_25  : year % 4 == 0 && (year % 16 == 0 || year % 25 != 0)
b25_4_16  : (year % 25 != 0 && year % 4 == 0) || year % 16 == 0
b25_16_4  : (year % 25 != 0 || year % 16 == 0) && year % 4 == 0
b16_4_25  : year % 16 == 0 || (year % 4 == 0 && year % 25 != 0)
b16_25_4  : year % 16 == 0 || (year % 25 != 0 && year % 4 == 0)
b16_25_4b : (year % 16 == 0 || year % 25 != 0) && year % 4 == 0

结果（实时此处):

同样，首先检查 4 的整除性看起来不是一个好主意。在这一轮中，快速是

b25_16_4  : (year % 25 != 0 || year % 16 == 0) && year % 4 == 0

4-100-400 次测试（无分支）

如前所述，分支可能会降低性能。特别是，短路可能会适得其反。在这种情况下，一个经典技巧是将逻辑运算符 && 和 || 替换为按位对应的 & 和<代码>|。实现变为：

nb4_100_400  : (year % 4 == 0) & ((year % 100 != 0) | (year % 400 == 0))
nb4_100_400b : ((year % 4 == 0) & (year % 100 != 0)) | (year % 400 == 0)
nb4_400_100  : (year % 4 == 0) & ((year % 400 == 0) | (year % 100 != 0))
nb100_4_400  : ((year % 100 != 0) & (year % 4 == 0)) | (year % 400 == 0)
nb100_400_4  : ((year % 100 != 0) | (year % 400 == 0)) & (year % 4 == 0)
nb400_4_100  : (year % 400 == 0) | ((year % 4 == 0) & (year % 100 != 0))
nb400_100_4  : (year % 400 == 0) | ((year % 100 != 0) & (year % 4 == 0))
nb400_100_4b : ((year % 400 == 0) | (year % 100 != 0)) & (year % 4 == 0)

结果（实时此处）：

一个值得注意的特征是，性能变化并不像分支情况那样明显，因此很难宣布获胜者。我们选择这个：

nb100_400_4  : ((year % 100 != 0) | (year % 400 == 0)) & (year % 4 == 0)

4-25-16 测试（无分支）

为了完成练习，我们考虑使用 4-25-16 整除性测试的无分支情况：

nb4_25_16  : (year % 4 == 0) & ((year % 25 != 0) | (year % 16 == 0))
nb4_25_16b : ((year % 4 == 0) & (year % 25 != 0)) | (year % 16 == 0)
nb4_16_25  : (year % 4 == 0) & ((year % 16 == 0) | (year % 25 != 0))
nb25_4_16  : ((year % 25 != 0) & (year % 4 == 0)) | (year % 16 == 0)
nb25_16_4  : ((year % 25 != 0) | (year % 16 == 0)) & (year % 4 == 0)
nb16_4_25  : (year % 16 == 0) | ((year % 4 == 0) & (year % 25 != 0))
nb16_25_4  : (year % 16 == 0) | ((year % 25 != 0) & (year % 4 == 0))
nb16_25_4b : ((year % 16 == 0) | (year % 25 != 0)) & (year % 4 == 0)

结果（实时 此处)：

再次，很难定义最好的，我们选择这个：

nb25_16_4  : ((year % 25 != 0) | (year % 16 == 0)) & (year % 4 == 0)

联赛

冠军 现在是时候挑选前面每个部分的最佳部分并进行比较：

b100_400_4  : (year % 100 != 0 || year % 400 == 0) && year % 4 == 0
b25_16_4    : (year % 25 != 0 || year % 16 == 0) && year % 4 == 0
nb100_400_4 : ((year % 100 != 0) | (year % 400 == 0)) & (year % 4 == 0)
nb25_16_4   : ((year % 25 != 0) | (year % 16 == 0)) & (year % 4 == 0)

结果（实时此处）：

该图表表明短路确实是一种优化，但被 4 整除应该是最后检查的而不是第一个检查的。为了获得更好的性能，应该首先检查是否能被 100 整除。这实在是太令人惊讶了！毕竟，后一个测试永远不足以确定年份是否为闰年，并且始终需要后续测试（通过 400 或通过 4）。

同样令人惊讶的是，对于分支版本，使用更简单的除数 25 和 16 并不比使用更直观的 100 和 400< /代码>。我可以提供我的“理论”，它也部分解释了为什么首先测试 100 比测试 4 更好。正如许多人指出的那样，4 的整除性测试将执行分为 (25%, 75%) 部分，而 100 的测试将其分为 (1%, 99%) 。在后一个检查之后，执行必须继续进行另一个测试并不重要，因为至少分支预测器更有可能正确猜测要走哪条路。同样，通过 25 检查整除性会将执行分为 (4%, 96%)，这对于分支预测器来说比 (1%, 99%) 更具挑战性。看起来最好是最小化分布的熵，以帮助分支预测器，而不是最大化早期返回的概率。

对于无分支版本，简化的除数确实提供了更好的性能。在这种情况下，分支预测器不起作用，因此越简单越好。一般来说，编译器可以用较小的数字执行更好的优化。

是这个吗？

我们是否碰壁并发现这

b100_400_4  : (year % 100 != 0 || year % 400 == 0) && year % 4 == 0

是闰年性能最好的检查？绝对不是。例如，我们没有混合分支运算符 && 或 || ，而没有分支运算符 & 和 |< /代码>。也许...让我们看看上面的内容并将其与其他两个实现进行比较。第一个是

m100_400_4 : (year % 100 != 0 || year % 400 == 0) & (year % 4 == 0)

（注意分支 || 和非分支 & 运算符的混合。）第二个是一个晦涩的“hack”：

bool b;
auto n = 0xc28f5c29 * year;
auto m = n + 0x051eb850;
m = (m << 30 | m >> 2);
if (m <= 0x28f5c28)
  b = n % 16 == 0;
else
  b = n % 4 == 0;
return b

后者有效吗？是的，确实如此。我建议不要给出数学证明，而是将上面发出的代码与这个更具可读性的来源的代码进行比较：

bool b;
if (year % 100 == 0)
  b = year % 16 == 0;
else
  b = year % 4 == 0;
return b;

在 Compiler 中资源管理器。它们几乎相同，唯一的区别是一个使用 add 指令，而另一个使用 lea 指令。这应该让您相信黑客代码确实有效（只要其他代码有效）。

基准测试结果（实时此处）：

等等，我听到你说，为什么不呢使用上图中更易读的代码？好吧，我已经尝试过并学到了另一个教训。当将此代码插入基准循环时，编译器将源代码作为一个整体进行查看，并决定发出与单独查看源代码时不同的代码。表现更差了。去算算吧！

现在呢？是这个吗？

我不知道！有很多事情我们可以探索。例如，最后一节展示了使用 if 语句而不是短路的另一个版本。这可能是获得更好性能的一种方法。我们还可以尝试三元运算符 ?。

请注意，所有测量和结论均基于 GCC-9.2。使用另一个编译器和/或版本，事情可能会改变。例如，GCC 从 9.1 版本开始引入了一种新的改进的整除性检查算法。因此，旧版本具有不同的性能，并且不必要的计算和分支错误预测之间的权衡可能已经改变。

我们绝对可以得出的结论是：

1. 不要想太多。优先选择清晰的代码而不是难以理解的优化（除非您是一个库编写者，围绕非常高效的实现为用户提供更高级别的 API）。毕竟，当您升级编译器时，手工制作的代码片段可能不是性能最高的选项。正如 ex-nihilo 在评论中所说，“对这样的一段代码大惊小怪没有什么意义，除非众所周知，这是一个性能瓶颈。”
2. 猜测很困难，最好进行测量。
3. 测量很困难，但比猜测更好。
4. 短路/分支可能有利于性能，但这取决于很多因素，包括代码对分支预测器的帮助程度。
5. 当片段内联到某处时，为孤立的片段发出的代码可能会有所不同。

Answer 4

int isLeapYear(int year)
{
   return (year % 400 == 0) || ( ( year % 100 != 0) && (year % 4 == 0 ));
}

Answer 5

这可能是正确的解决方案。维基百科上给出的算法不正确。

-(BOOL)isLeapYear: (int)year{    

    if(year%4==0){
      if(year%100!=0){
        return YES;
     }
     else if(year%400!=0){
        return YES;
     }
     else return NO;
   }

    else return NO;
  }

Answer 6

虽然先除以 400 的逻辑无可挑剔，但它的计算效率不如先除以 4。您可以使用以下逻辑来做到这一点：

#define LEAPYEAR(y) (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0))

对于每个值都除以 4，但对于其中的 3/4，测试将在此终止。对于通过第一次测试的 1/4，然后除以 100，消除 24/25 个值；对于 100 中剩下的 1，它也除以 400，得出最终答案。当然，这并不是一个巨大的节省。

Answer 7

来自关于闰年的维基百科文章：

if (year modulo 4 is 0) and (year modulo 100 is not 0) or (year modulo 400 is 0)
   then is_leap_year
else
   not_leap_year

Answer 8

您的代码的问题在于，如果您认为年份是闰年，那么您将从 yearr 返回非零值。因此，您的 if 语句中不需要 ! 。

Answer 9

http://www.wwu.edu/depts/skywise/leapyear.html

闰年规则

每年都有一个闰年
数字可以被四整除
- 既能被 100 整除又不能被 100 整除的年份除外
400. 规则的第二部分影响世纪年。例如;
1600年和2000年是
闰年，而是世纪年
1700、1800 和 1900 不是。这
意味着每一次中有三次
四百年有八年
闰年之间的年数。

Answer 10

 if(year%400 ==0 || (year%100 != 0 && year%4 == 0))
    {
        printf("Year %d is a leap year",year);
    }
    else
    {
        printf("Year %d is not a leap year",year);
    }

像上面那样改变它。另请阅读此内容。

Answer 11

    #include 
    void main(void)
    {
        int year;
        printf("Enter a year to check if it is Leap Year\n");
        scanf("%d",&year);
        if(year%400==0) /* Why  mod 400 */
            printf("%d is a Leap Year\n",year);
        else if(year%100==0) /*  Why  mod 100  */
            printf("%d is not a Leap Year\n",year);
        else if(year%4==0)
            printf("%d is a Leap Year\n",year);
        else
            printf("%d is not a Leap Year\n",year);

    }

Answer 12

I used this code:

#include <stdio.h>

int main()
{
    int yr;
    printf ("Enter a year \n");
    scanf ("%d", &yr);

    if (yr%400 == 0)
        printf("\n LEAP YEAR.");

    else if (yr%4==0 && yr%100!=0)
        printf("\n LEAP YEAR.");
    else
        printf ("\n NOT LEAP YEAR.");
}

Answer 13

这里还有另外 2 个解决方案，它们似乎在 quick-bench.com 基准测试中击败了之前的解决方案。

这个有一个测试，但使用 clang 编译为无分支代码：

int isleap3(int year) {
    unsigned y = year + 16000;
    return (y % 100) ? !(y % 4) : !(y % 16);
}

这个使用单个模运算并且没有测试，并且仅编译为 2 个乘法：

static unsigned char const leaptest[400] = {
    1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,
    0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,
    0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,
    0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,
    0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,
    0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,
    0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,
    0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,
    0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,
    0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,
    0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,
    0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,
    0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,
    0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,
    0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,
    0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,
};
int isleap4(int year) {
    unsigned y = year + 16000;
    return leaptest[y % 400];
}

clang 64 位程序集：

isleap3:                                # @isleap3
        add     edi, 16000
        imul    eax, edi, -1030792151
        ror     eax, 2
        cmp     eax, 42949673
        mov     eax, 15
        mov     ecx, 3
        cmovb   ecx, eax
        xor     eax, eax
        test    ecx, edi
        sete    al
        ret
isleap4:                                # @isleap4
        add     edi, 16000
        imul    rax, rdi, 1374389535
        shr     rax, 39
        imul    eax, eax, 400
        sub     edi, eax
        movzx   eax, byte ptr [rdi + leaptest]
        ret
leaptest:
        .asciz  "\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\000\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\000\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\000\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000\000\001\000\000"

这是基准测试结果 >:

Answer 14

正如其他人也提到的那样，闰年的条件不正确。它应该：

int yearr(int year)  
{  
    if(((year%4 == 0) && (year%100 !=0)) || (year%400==0))  
        return 1;    
    else    
        return 0;    
}  

在这里阅读如何检查闰年在 C 中。

Answer 15

Kevin 的答案提供了最佳的 8 操作测试（使用常量进行异或），但如果您正在寻找更具可读性的东西，请尝试这个 9 操作测试。

year % 4 == 0 && !((year % 100 == 0) ^ (year % 400 == 0))

(year % 100 == 0) ^ (year % 400 == 0) 的真值表

                              (year % 100 == 0) ^ (year % 400 == 0)
100 doesnt divide year     .    F
only 100 divides year      .    T
100 and 400 divides year   .    F

!(year % 100 == 0) ^ (year % 400 == 0)< /code> 给出你想要的。

Answer 16

计算月份的最大/最后一天：1..12，年份：1..3999

maxDays = month == 2 ?
  28 + ((year & 3) == 0 && ((year % 25) != 0 || (year & 15) == 0)) :
  30 + ((month & 1) ^ (month > 7));