この課題は非常に簡単です。1801から2400までの年になる入力を受け取り、うるう年かどうかを出力します。

入力には改行や末尾のスペースは含まれません。

1954

好きな方法で出力して、うるう年かどうかをユーザーに明確に伝えます（yes / noの場合はyまたはnを受け入れます）

ここでうるう年のリストを取得できます：http : //kalender-365.de/leap-years.php うるう年は常に4年ではないことに注意してください。1896年はle年ですが、1900年はそうではありません。この「スキップ」に続く年は次のとおりです。

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文字

0うるう年ではなく、うるう年を返します1。

≥/⌽×4 25 4⊤⎕

tryapl.orgでこのソリューションを試してください。{≥/⌽×4 25 4⊤⍵}tryapl.comがサポートしていない⎕（ユーザー入力を取得する）ため、dfnのソリューションを変更していることに注意してください。⎕は空のボックスであり、文字が欠落していないことに注意してください。

Jの同じソリューション：

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

説明

Dyadic ⊤（エンコード）は、左引数で指定されたベースの右引数を表します。4 25 4このソリューションではbaseを使用します。これは、y年を多項式として表します

y mod 400 = 100 a + 4 b + c  ここで、b <100およびc <4。

命題は聞かせて、β、α、及びγ場合表し、 B、及びCは非ゼロである：提案γ偽の場合、yは 4で割り切れるである、β ∧ γであれば偽Yが 100とによって分割可能であるα ∧ β ∧ γ IS yが400で割り切れる場合はfalse 。

真理値表（*「ドントケア」を表す）は、yがうるう年である場合に命題Δが表すことです。

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

以下のステートメントは、α、β、およびγで Δを表します。

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

このステートメントの構造により≥/⌽α β γ、≥が←を実装する場合の縮約として¬Δを表現できます。これは私が今説明している答えにつながります。

Pyth、11バイト

!%|F_jQ*TT4

この完全なプログラムは、STDINから読み取られ、うるう年の場合はTrue、そうでない場合はFalseを出力します。

Pythを提案し、基本的に私のCJamコードを移植してくれた@Jakubeに感謝します。

Pyth Compiler / Executorでテストケースを自分で検証します。

使い方

     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から読み取られ、うるう年の場合は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文字

標準的なルールは、y4が除算されy、100が除算されないyか、400が除算される場合、うるう年yです。コードでは、

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

その100と400は必要ありません。代わりに、16か4がyを分割するかどうかをチェックするだけで十分です。ゴルフ、これは

!(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バイト

これは最初に登場したよりも興味深いものでした。これは、いくつかのfinaglingを取ったが、私は最終的にそれらの長い参照置き換えることができた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

簡単すぎる。オンラインで試す：デモンストレーションまたはテストハーネス

編集：見逃した、あなたはの代わりに、真実/偽の値を印刷できること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と$= \ZRubyの場合）：

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)?)$

最初の100000年間、Rubyでテストします（^= \Aと$= \ZRubyのため）：

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)主にDe Morgansの法則を使用）

ルールを実装する関数：

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で除算します。

20-> 17クローズコードを削除できるようにコードを再配置する。17->16。400を16に置き換えます。16-> 13デビッドハモンドのアイデアを使用して。

Stackylogic、226バイト（非競合）

はいそうです。ここにある課題のために、ヘルカ・ホンバによって発明されたStackylogic（非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には数学関数がないため、これが難しくなりました。それが特定の数であるかどうかを確認するために、私はそれのほとんどをハードコードしなければなりませんでした。

まず、このプログラムは最下位ビットのNORを実行し、プロセスでそれらを破棄します。これは、4で割り切れる場合はプログラムのメイン部分に進み、それ以外の場合は0を出力することを意味します。

第二に、ポインタはstackylogicの迷路に持ち越され、ここから、次の2ビットがゼロの場合、即座に1を出力します（16で割り切れるので、他の条件にもかかわらずうるう年）、その他賢明なことに、4で割り切れる数ではなく、1801から2400までのle年ではないかどうかをチェックします。

詳細に説明するには、この投稿を既存の何倍も長くする必要があります

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 

新しいバージョン。これは、うるう年の場合は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  

OK、それで最短ではありません（ただし、実際に実行されたコードとインタープリターのサイズを見ると...）

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、そうでない場合はS222（CPU時間がなくなった場合）。

1936年1805年N 1900年N 2272年2400年

（複数回実行する場合）

CJam、18 16バイト

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

1うるう年は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

私はもっ​​と短くすることができますが、これは引数を解析せずに（たとえばatoi）、「char」型にきちんと固執します：

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

これは、引数がプログラム名の直後にNULで区切られているという標準的な仮定を行うため、4文字の名前で呼び出す必要があります。さらに、単一の引数が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の「10」桁の位置ですv[1]+2。

「10」と「単位」の文字が96になると、で終わる00ため、2つの文字をバックアップし、「10」と「単位」が世紀数を指すようにします。

これでxor 'units'が 'tens'の2倍、mod 4になります。これはが動作するため10==±2 mod 4です。結果を剰余表へのインデックスとして使用し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で除算します。
• 2行目は、奇数桁に「N」、4桁に「y」、4桁以外に「n」を与えます。
• 最後から2番目の数字が奇数の場合、3行目は「y」と「n」を入れ替えます（10は2 mod 4であるため）
• 最終行は最後の文字を除くすべてを削除します

非うるう年のように印刷することができることを注意nやN、彼らが偶数か奇数かによって。これは、ルールの創造的な解釈であり、一貫性が必要であることを明記せずに「はい」と「いいえ」の代替案を認めています。

Python2-37

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

if aが非負の整数である場合、a<1を書く簡単な方法であることに注意してくださいnot bool(a)。<1したがって、最後のものは、括弧内の式を事実上ブール値に変換し、結果を否定します。

1801〜2400のg整数に関数を適用すると、うるう年の場合nに戻り、そうでない場合に戻ります。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

@OlivierGrégoireのおかげで-2バイト。

オンラインでお試しください。

約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バイト

末尾のスペース/改行の有無にかかわらず、stdinから入力を取得します。リトルエンディアンマシンでのみ動作します（ええ、誰もが最近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に割り当てられます。はになりました0x000000??。ここ0x??で、割り当てられた文字はです。これはリトルエンディアンのマシン上にあり、メモリにとして保存され?? 00 00 00ます。これは、割り当てられた文字のみを含む、NULLで終了するC文字列です。yのアドレスがputsに渡され、charが（末尾の改行付きで）印刷されます。

PowerShell、31バイト

私はこのビルトインよりも短いゴルフをしたと言って興奮しています！

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

うるう年の場合はtrue、そうでない場合はfalseを出力します。

ビルトイン：

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

ただし、「うるう年かどうかをユーザーに明確に伝える」ステートメントを拡張し、非標準的なことをしたい場合は、3バイトを節約して使用できます：

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

これ0はうるう年の出力であり、うるう年以外の場合は1以上です。うるう年にはより標準的な真理値を返すことを好むので、これは好ましくありません。

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

LOLCODEが混乱しているため、Pythonでolfolfed：

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