这个挑战很简单。您将输入从1801到2400的年份，如果不是output年则输出。

您的输入将没有换行符或尾随空格：

1954

您将以自己喜欢的任何方式输出，以清楚地告诉用户是否是a年（我将接受y或n作为是/否）。

您可以在此处获得of年列表：http : //kalender-365.de/leap-years.php 我要指出的是leap年并非总是4年。1896年是a年，但1900年不是a年。此“跳过”之后的年份是：

1900
2100
2200
2300

测试用例：

1936 ->  y
1805 ->  n
1900 ->  n
2272 ->  y
2400 ->  y 

编辑：这是基于标准的格里高利历：http : //www.epochconverter.com/date-and-time/daynumbers-by-year.php

APL，16 14 12个字符

返回0for年，1非-年。

≥/⌽×4 25 4⊤⎕

在tryapl.org上尝试此解决方案。请注意，我已将解决方案更改为dfn，{≥/⌽×4 25 4⊤⍵}因为tryapl.com不支持⎕（接受用户输入）。请注意，这⎕是一个空框，而不是缺少的字符。

J中的相同解决方案：

4 25 4>:/@|.@:*@#:]

说明

Dyadic ⊤（编码）在其左参数指定的基数中表示其右参数。我4 25 4在此解决方案中使用base 。这表示年份y为多项式

y mod 400 = 100 a + 4 b + c  其中b <100且c <4

让命题α，β，和γ如果表示一个， B，和C ^是非零：命题γ是假，如果ý是由4整除，β ∧ γ是假，如果ý是由100和可分割α ∧ β ∧ γ 就是如果y可除以400，则返回false 。

*命题Δ表示的真值表（表示“无关”）表示y是a年时获得：

α β γ | Δ
0 0 0 | 1
1 0 0 | 0
* 1 0 | 1
* * 1 | 0

以下语句表示α，β和γ中的 Δ ：

Δ＝¬（（α → β）→ γ））。

由于该语句的结构，可以将¬Δ表示为≥/⌽α β γ≥实现← 的简化。这导致了我现在正在解释的答案。

Pyth，11个字节

!%|F_jQ*TT4

此完整程序从STDIN读取，并在leap年时输出True，否则输出False。

感谢@Jakube建议Pyth并基本上移植了我的CJam代码。

在Pyth编译器/执行器中亲自验证测试用例。

这个怎么运作

     jQ*TT   Returns the evaluated input in base 10 × 10.
  |F_        Swaps the digit order and reduces using logical OR.
             So far, we've achieved 1954 -> [19, 54] -> 54 || 19.
!%        4  Returns the logical NOT of the result modulo 4.
             This prints True for multiples of 4 and False otherwise.

CJam，12个字节

rS+2m<~e|4%!

该完整程序从STDIN读取，并在leap年时打印1，否则打印0。

在CJam解释器中自己验证测试用例。

这个怎么运作

r   e# Read from STDIN.
S+  e# Append a space.
2m< e# Rotate two characters to the left.
~   e# Evaluate.
    e# So far, we achieved "1954" -> "54 19" -> 54 19.
e|  e# Logical OR; keep the leftmost non-zero integer.
4%! e# Logical NOT of the kept integer modulo 4.
    e# This pushes 1 for multiples of 4 and 0 otherwise.

Javascript（ES6），21个字符

标准规则是y如果除以4 y并且除以100 y或除以400 则为a年y。在代码中

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

不需要100和400。而是只需检查16或4除以y，如果25除以y，则选择16，否则选择4。打高尔夫球，这成为

!(y%(y%25?4:16))

实现此功能的javascript函数长21个字符：

l=y=>!(y%(y%25?4:16))

Perl，28个 26个字符

相同的想法，但是在perl中。

$_=$_%($_%25?4:16)?"n":"y"

使用-lp选项运行。例如，

perl -lpe '$_=$_%($_%25?4:16)?"n":"y"'

将测试集作为输入，这将产生

1936
y
1805
n
1900
n
2272
y
2400
y

点，13字节

这个比最初出现时更有趣。花了一些时间，但我终于能够400用4和h变量（= 100）替换那些冗长的引用。

!(a%h?aa/h)%4

输出1为闰年，0对于非闰年。说明：

               a is command-line argument (implicit)
  a%h?aa/h     If a is divisible by 100, divide it by 100; otherwise, leave it alone
 (        )%4  The result mod 4 is 0 if it's a leap year, nonzero otherwise
!              Negate and (implicitly) print

Pyth，19 15 14字节

xFm!%Q^d2[2TyT

太简单了。在线尝试：演示或测试工具

编辑：错过了，您可以打印Truthy / Falsy值，而不是n/y。-4字节

编辑2：使用马丁的平方根的想法。-1字节

说明

                 implicit: Q = input number
         [         generate a list with the numbers:
          2          2
           T         10
            yT       2*10 = 20
  m              map each number d to:
   !%Q^d2          not(Q mod d^2) // True if Q % d^2 == 0 otherwise False
xF               fold by xor

正则表达式83 62 38

感谢Toby提供了有关将正则表达式的两半合并的提示。

如果仅关注1801..2400范围，并假设输入为整数：

(?!00)([02468][048]|[13579][26])(00)?$

在Ruby中测试（^= \A和$=，\Z因为Ruby）所需的范围：

r = /(?!00)([02468][048]|[13579][26])(00)?\Z/
(1801..2401).each do |year|
  leap = year % 4 == 0 && ((year % 100 != 0) || (year % 400 == 0))
  leap_regex = !year.to_s[r].nil?
  if leap != leap_regex
    print 'Assertion broken:', year, " ", leap, " ", leap_regex, "\n"
  end
end

（奖金）适用于不仅适用于1801..2400，而且适用于任何非负年份的事物：

^\d*(0000|(?!00)([13579][26]|(^|[02468])[048])(00)?)$

在Ruby中测试100000年（^= \A和$= \Z因为Ruby）：

r = /\A\d*(0000|(?!00)([13579][26]|(\A|[02468])[048])(00)?)\Z/
100000.times do |year|
  leap = year % 4 == 0 && ((year % 100 != 0) || (year % 400 == 0))
  leap_regex = !year.to_s[r].nil?
  if leap != leap_regex
    print 'Assertion broken:', year, " ", leap, " ", leap_regex, "\n"
  end
end

JavaScript（ES6）27

规则： (y%4==0) && (y%100!=0 || y%400==0)

打高尔夫球：（!(y%100<1&&y%400||y%4)主要使用德摩根定律）

一个实现规则的函数：

l=y=>!(y%100<1&&y%400||y%4)

一个测试（在Firefox中运行）只是为了确保：

l=y=>!(y%100<1&&y%400||y%4)

for(o=[],i=0;i<700;i++)
  y=i+1800,
  x=l(y),
  o[i/100|0]=(o[i/100|0]||'')+y+(x?' <b>Y</b>':' <i>N</i>')+'\n'
    
R.innerHTML='<td>'+o.join('</td><td>')+'</td>'
console.log(o[1])

td { white-space: pre; font-family: monospace; padding: 8px}

b { color: red; }
i { color: blue; }

<table>
  <tr id=R></tr>
</table>

TI-BASIC，20 17 16 13年

因为它是标记化的，所以TI-BASIC在简单的数学挑战中通常具有竞争力，但由于没有“可分割的”命令，因此没有这一优势。也许是毕竟，但这仍然比CJam和Pyth长。

这使用David Hammond的方法。

not(fPart(Ans/4/4^not(fPart(sub(Ans

16字节的旧代码：

not(fPart(Ans/16not(fPart(sub(Ansnot(fPart(Ans/4

取消高尔夫：

not(fPart(Ans/16) and not(fPart(Ans/100) and not(fPart(Ans/4))))

fPart(是“小数部分”；求幂的优先级高于除法。在TI-BASIC中，关闭括号是可选的。

我使用sub(命令的未记录行为，通常用于获取子字符串：当其参数是数字而不是字符串时，它将数字除以100。它将在TI-83或84系列计算器上运行。

20-> 17，通过重新排列代码以允许删除近亲；17-> 16，将400替换为16；16-> 13通过使用David Hammond的想法。

Stackylogic，226个字节（非竞争）

是的，这是正确的。我在Helka Homba发明的Stackylogic（non-TC）中编写了一个程序，以应对此处遇到的挑战。这是在挑战之后做出的，因此是非竞争的。

Stackylogic仅具有二进制输入，因此必须使用10位（或更多，将忽略更多数字）二进制位（首先输入最低有效位）。任何超出指定范围的日期都可能失败，因为它只是检查输入的数字是什么：它不包含不必要的日期

这不仅是我对stackylogic的第一个挑战，而且也是我对stackylogic的第一个挑战。

为这个混乱做好准备：

1
0
1?
010
1?0
010
1?10
?1010
001010
?1010
?1010
?010
?10
?0
0
?
110
?10
11010
?010
11010
?1010
001010
?1010
?1010
?1010
?1010
?010
?0
110
?10
11010
?010
1010
01010
01010
?010
?0
110
?0
110
?0
110
1?0
?10
0?10
?10
?0
01
?
?<
0

这花了我很长时间，因为Stackylogic是我遇到过的最令人困惑的语言，而且极不可读：您必须先了解程序的其余部分是如何执行的，然后才能阅读当前正在编辑的部分。创建它时，我什至不得不添加空格以提高可读性。

微不足道的解释

这是对其功能的简单说明。

Stackylogic没有任何数学函数，因此这变得更加困难。我必须对其中的大部分进行硬编码，以检查它是否为特定数字。

首先，该程序将对最低有效位进行“或非”运算，并在处理过程中将其丢弃。这意味着如果它可以被4整除，它将进入程序的主要部分，否则输出0。

其次，将指针移到stackylogic的迷宫中，从这里开始，如果接下来的两位为零，则它将立即输出1（因为它可以被16整除，因此在任何其他条件下都可以是a年），其他明智的做法是检查1801和2400之间的数字是否可以被4整除而不是a年。

要详细解释，将涉及使此帖子的长度比原来长很多倍

IBM System Z汇编程序-56个字节。

（96个字节源的。此前712个 384 202字节源的，168字节可执行文件）。

较小的版本。不再保存调用者的寄存器，更改为文字存储，更改寻址方式。

 l        CSECT      
         using l,15 
         l  5,y     
         n 5,f      
         bnz r      
         xr 4,4     
         l 5,y      
         d 4,c      
         ch 4,i     
         bne i      
         n 5,f      
         bnz r      
i        dc h'0'    
r        b  *       
y        dc f'2004' 
f        dc f'3'    
c        dc f'100'  
         end 

新版本。如果是a年，它将与S0C1结合使用，如果不是，则循环。希望能满足指示结果的要求。

l        CSECT             
         ASMDREG           
         SYSSTATE archlvl=2
         IEABRCX  DEFINE   
         save  (14,12)     
         larl  r9,s        
         using s,r9        
         st 13,w+4         
         la 13,w           
         st 13,w+8         
         la 5,2004         
         st 5,y            
         n 5,=f'3'         
         bnz r             
         xr r4,r4          
         l 5,y             
         d r4,=f'100'      
         ch r4,=h'0'       
         bne i             
         n 5,=f'3'         
         bnz r             
i        dc h'0'           
r        b  0              
s        dc 0d'0'          
y        ds f              
w        ds 18f            
         ltorg             
         end  

好的，所以不是最短的（尽管可能只有一次，我们查看实际执行的代码加上解释器的大小...）

leapyear CSECT                                                
         ASMDREG                                              
         SYSSTATE archlvl=2                                   
         IEABRCX  DEFINE                                      

         save  (14,12)                                        

         larl  r9,staticArea                                  
         using staticArea,r9                                  
         st r13,w_savea+4       .Save callers savearea        
         la r13,w_savea         .Address my savearea          
         st r13,w_savea+8         . and save it               

         open  (O,OUTPUT)             .open file              

         la r5,1936             .r5 = input year              
         st r5,years            .Save year                    

         cvd r5,double          .Convert year to p-decimal    
         mvc edarea,=xl8'4020202020202120' .Move in edit mask 
         ed edarea,double+4      .Make packed decimal year printable                              
         mvc outrec(4),edarea+4  .Move year string to output area                             
         bas r10,isitleap       .Call leap year routine       

         close (O)              .Close files            
         b return               .Branch to finish

isitleap ds 0h                                                      
         mvi outrec+5,c'N'      .Set default value                                   
         n r5,=f'3'             .Are last 2 bits 0 (Divisible by 4)?
         bnz notleap            .No - not leap                      
         xr r4,r4               .Clear R4                           
         l r5,years             .Reload r5 with year                
         d r4,=f'100'           .divide r4/r5 pair by 100           
         ch r4,=h'0'            .Remainder 0?                       
         bne isleap             .No - leap year                     
         n r5,=f'3'             .Quotient divisible by 4?           
         bnz notleap            .No - not leap                      

isleap   ds    0h                                                   
         mvi outrec+5,c'Y'      .Move in leap year indicator                                    

notleap  ds    0h                                                   
         put O,outrec           .Print output record                                    
         br r10                 .Return to caller                   

* Program termination                                               
return   ds 0h                                                      
         l r13,w_savea+4         .Restore callers savearea          
         return (14,12),,rc=0    .Restore registers and return    
* storage areas                                                     
staticarea  dc 0d'0'                                                
outrec      ds cl10                                                 
years       ds f                                                    
w_savea     ds 18f                save area                         
edarea      ds cl8                    .edit area                    
double      ds d                                                    
* Macros and literals                                               
         print nogen                                                
O        dcb   recfm=F,lrecl=6,dsorg=PS,ddname=O,macrf=PM           
         print gen                                                  
*                                                                   
         ltorg                         literal storage              
         end  

输出：

如果不是，则将S0C1终止为a年，否则为S222（CPU时间用尽时）。

1936是1805 N 1900 N 2272是2400 Y

（多次运行时）

CJam，18个16字节

q~[YAK]f{2#%!}:^

给出1（真实的）leap年，0否则给出（虚假的）。

在这里运行所有测试用例。

说明

q~                 e# Read and eval input.
  [YAK]            e# Push an array containing 2, 10, 20 (the square roots of the
                   e# relevant divisors).
       f{    }     e# Map this block onto that array, also passing in the input year.
         2#        e# Square the divisor.
           %!      e# Modulo followed by logical negation. Gives 1 if the year is divisible
                   e# by the given divisor and 0 otherwise.
                   e# At this point we have one of the following arrays:
                   e#   [0 0 0] - not a leap year
                   e#   [1 0 0] - a leap year
                   e#   [1 1 0] - not a leap year
                   e#   [1 1 1] - a leap year
              :^   e# Reduce XOR onto this array, which gives 1 if there is an odd number
                   e# of 1s and 0 if there's an even number.

Mathematica，40个 27字节，17个字符

#∣4∧(#∣100<U+F523>#∣400)

使用17个字符，但27个字节。感谢@alephalpha的提示。请注意，竖线实际上是用于分隔的U + 2223。的<U+F523>应替换为相应的字符。

R，29

!(Y=scan())%%4&Y%%100|!Y%%400

测试运行

> !(Y=scan())%%4&Y%%100|!Y%%400
1: 1936
2: 1805
3: 1900
4: 2272
5: 2400
6: 2200
7: 
Read 6 items
[1]  TRUE FALSE FALSE  TRUE  TRUE FALSE

C，81

我可以做的更短一些，但是这个整洁地坚持使用'char'类型，而无需解析参数（例如atoi）：

main(c,v)char**v;{char*p=*v+9;p-=2*(96==*p+p[1]);putchar("ynnn"[(2**p^p[1])&3]);}

必须使用长度为4个字符的名称来调用它，因为这是标准的假设，即参数紧跟程序名称，并以NUL分隔。此外，它假定单个参数以ASCII编码且没有前导空格。

说明：

main(c,v)
char**v;
{
    char *p = *v+9;
    if (p[0] + p[1] == '0'+'0')
        p -= 2;
    putchar("ynnn"[((*p << 1) ^ p[1])&3]);
}

*v+9是“十”位在中的位置v[1]+2。

如果'tens'和'units'字符加到96，我们以结尾00，则备份两个字符，以使'tens'和'units'指向世纪数字。

现在，将“单位”与“十”的两倍进行修改，这是mod 4的两倍。之所以起作用，是因为10==±2 mod 4，因此“十”的低位可以切换“单位”的第1位。我们将结果用作余数表的索引，y仅当模块化结果为零时才打印。

Befunge -98，（41个字节）

&:4%#v_:aa*%#v_28*%|
"y",;<;@,"n";>;  ;#[

简单性真棒。

sed，55岁

s/00$//
y/0123456789/yNnNyNnNyN/
/N.$/y/ny/yn/
s/.\B//g

• 第一行将确切的世纪除以100。
• 第二行将“ N”赋予奇数位，“ y”赋予4s，而“ n”赋予非4s。
• 如果倒数第二个奇数位（因为10是2 mod 4），则第三行交换'y'和'n'
• 最后一行删除除最后一个字符外的所有字符

请注意，非-年可能会打印为偶数或奇数n或N取决于偶数或奇数。我认为这是对规则的创造性解释，该规则允许对“是”和“否”的替代方案，而不必指明它们必须保持一致。

Python2-37

g=lambda x:(x%4or x%400and x%100<1)<1

请注意，如果a是非负整数，则a<1是一种简短的编写方法not bool(a)。因此，最后一个<1有效地将括号中的表达式转换为布尔值并取反。

如果是a年，则将函数g应用于n1801和2400之间的整数将返回。TruenFalse

KDB（Q），27个字节

{0=x mod(4 400)0=x mod 100}

说明

               0=x mod 100      / boolean of 100 divisibility
        (4 400)                 / 0b -> 4, 1b -> 400
 0=x mod                        / boolean of 4/400 divisibility
{                         }     / lambda

测试

q){0=x mod(4 400)0=x mod 100}1936 1805 1900 2272 2400
10011b

朱莉娅，30 28字节

y->(y%4<1&&y%100>0)||y%400<1

这将创建一个未命名函数，该函数接受一个整数参数并返回一个布尔值。要给它起个名字，例如f=y->...。

取消高尔夫：

function f(y)
    (y % 4 == 0 && y % 100 != 0) || y % 400 == 0
end

例：

julia> for y in [1936, 1805, 1900, 2272, 2400] println(f(y)) end
true
false
false
true
true
true

PHP-45个字节

$b=$argv[1]%400;echo !$b|!($b%4)&!!($b%100);

没什么特别的，只是滥用类型杂耍。

C＃，23个字节

y=>y%25<1?y%16<1:y%4<1;

在线尝试！

完整的源代码，包括测试用例：

using System;

namespace CountingLeapYears
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<int,bool>s=y=>y%25<1?y%16<1:y%4<1;
            Console.WriteLine(s(1936)); //y
            Console.WriteLine(s(1805)); //n
            Console.WriteLine(s(1900)); //n
            Console.WriteLine(s(2272)); //y
            Console.WriteLine(s(2400)); //y
        }
    }
}

C，37 34 30字节

l(y){y=y%(y%25?4:16)?110:121;}

魔盒

T-SQL 37 22字节

感谢BradC的评论，节省了15个字节。

缺少的通常的硬编码变量stdin。

例如

DECLARE @ NVARCHAR(4) = '2016'

那么解决方案是：

PRINT ISDATE(@+'0229')

Java 8，49 45 22 20字节

n->n%(n%25<1?16:4)<1

-2个字节，感谢@OlivierGrégoire。

在线尝试。

一些22字节的解决方案：

n->n%25<1?n%16<1:n%4<1

在线尝试。

n->(n%25<1?n%16:n%4)<1

在线尝试。

java.time.Year::isLeap

在线尝试。

说明：

n->                // Method with integer parameter and boolean return-type
   n%          <1  //  Return whether the integer is divisible by:
     (n%25<1?      //   If the input is divisible by 25:
             16    //    Check if its divisible by 16
            :      //   Else:
             4)    //    Check if its divisible by 4 instead

Haskell，19个字节

f i=gcd 80i>gcd 50i

在线尝试！

Javascript ES6、32、29、26

以下任何行均有效：

f=y=>new Date(y,2,0).getDate()&1
g=y=>!(y&3)^!(y%100)>!(y%400)
h=y=>!(y&3|y%100<1&&y%400)

C，57字节

从标准输入接收输入，带或不带尾随空格/换行符。仅可在小型字节序计算机上使用（是的，就像现在每个人都在BE上一样）。输出Y或N。

main(y){scanf("%d",&y);y=y%(y%100?4:400)?78:89;puts(&y);}

说明

取消高尔夫：

int main(int y) {
   scanf("%d", &y);
   y = y % (y % 100 ? 4 : 400) ? 'N' : 'Y';
   puts(&y);
}

首先，scanf将年读取为y中的整数。然后，根据年份是否可以被100整除，将y与4或400进行模运算。如果余数为零，则将y的ASCII码分配给y，否则将得到n的ASCII码。y的值现在是，指定的字符0x000000??在哪里0x??。在小端机上，这在内存中存储为?? 00 00 00。这是一个以NULL终止的C字符串，仅包含分配的字符。y的地址传递到puts并打印char（带有结尾的换行符）。

PowerShell，31个字节

我很高兴地说自己打的比内置高尔夫短！

param($a)!($a%(4,16)[!($a%25)])

输出leap年为true，否则为false。

内建：

[datetime]::IsLeapYear($args[0])

但是，如果我想扩展该语句“清楚地告诉用户它是否是year年”并执行一些非标准的操作，则可以节省3个字节并使用：

param($a)$a%(4,16)[!($a%25)]

此输出0用于leap年，对于非le年则输出1或更高，我不喜欢，因为我希望为prefer年返回更标准的真实值。

LOLCODE，228个 202 159字节

HOW IZ I f YR a
MOD OF a AN 100
O RLY?
YA RLY
MOD OF a AN 4
O RLY?
YA RLY
b R 1
OIC
NO WAI
MOD OF a AN 400
O RLY?
YA RLY
b R 0
NO WAI
b R 1
OIC
OIC
IF U SAY SO

取消高尔夫：

HAI 1.3 BTW "HAI" does nothing functionally in current versions and does not throw an error if you omit it.
HOW IZ I leap YR input
    I HAS A output
    DIFFRINT MOD OF input AN 100 AN 0 BTW Thanks @LeakyNun, In LOLCODE any non-empty values, i.e. 0, "", etc. default to WIN.
    O RLY?
        YA RLY
            BOTH SAEM MOD OF a AN 4 AN 0
            O RLY?
                YA RLY
                    output R WIN BTW "WIN" is true, but in the actual program I used 1 as a truthy value because it's shorter.
            OIC
        NO WAI
            DIFFRINT MOD OF a AN 400 AN 0
            O RLY?
                YA RLY
                    output R FAIL BTW "Fail" is false, but in the actual program I used 0 as a falsy value.
                NO WAI
                    output R WIN
            OIC
    OIC
    FOUND YR output BTW This statement is implied in the golfed version.
IF U SAY SO BTW "KTHXBYE", just like "HAI" has no functional purpose and throws no error on omission.
KTHXBYE

在Python中，由于LOLCODE令人困惑，因此：

def leap:
    if(year % 100 != 0):
        if(year % 4 == 0):
            output = true
    else:
        if(year % 400 != 0):
            output = false
        else:
            output = true
    return(output)