Diese Herausforderung ist ganz einfach. Sie nehmen eine Eingabe, die ein Jahr von 1801 bis 2400 ist, und geben aus, ob es ein Schaltjahr ist oder nicht.

Ihre Eingabe wird keine Zeilenumbrüche oder Leerzeichen enthalten:

1954

Sie geben auf jede Art und Weise aus, die Ihnen gefällt, und teilen dem Benutzer klar mit, ob es sich um ein Schaltjahr handelt oder nicht (ich akzeptiere y oder n für yes / no).

Eine Liste der Schaltjahre finden Sie hier: http://kalender-365.de/leap-years.php Ich möchte darauf hinweisen, dass Schaltjahre nicht immer vier Jahre sind. 1896 ist ein Schaltjahr, 1900 nicht. Die Jahre, die diesem "Überspringen" folgen, sind:

1900
2100
2200
2300

Testfälle:

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

BEARBEITEN: Dies basiert auf einem gregorianischen Standardkalender: http://www.epochconverter.com/date-and-time/daynumbers-by-year.php

APL, 16 14 12 Zeichen

Gibt 0für ein Schaltjahr zurück, 1für ein Nicht-Schaltjahr.

≥/⌽×4 25 4⊤⎕

Probieren Sie diese Lösung auf tryapl.org aus . Beachten Sie, dass ich die Lösung auf dfn geändert habe, {≥/⌽×4 25 4⊤⍵}da tryapl.com dies nicht unterstützt ⎕(Benutzereingaben übernehmen). Beachten Sie, dass ⎕es sich um ein leeres Feld handelt und kein fehlendes Zeichen.

Die gleiche Lösung in J:

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

Erläuterung

Dyadic ⊤(encode) repräsentiert sein rechtes Argument in der Basis, die durch sein linkes Argument angegeben wird. Ich benutze Basis 4 25 4in dieser Lösung. Dies repräsentiert das Jahr y als Polynom

y mod 400 = 100 a + 4 b + c  wobei b <100 und c <4.

Lassen Sie die Sätze α, β und γ darstellen, wenn a, b und c nicht Null sind: Satz γ ist falsch, wenn y durch 4 teilbar ist , β ∧ γ ist falsch, wenn y durch 100 teilbar ist und α ∧ β ∧ γ ist false, wenn y durch 400 teilbar ist.

Eine Wahrheitstabelle ( *die "egal" darstellt), in der Satz & Dgr; darstellt, wenn y ein Schaltjahr ist, ergibt sich:

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

Die folgende Aussage drückt Δ in α , β und γ aus :

Δ = ¬ (( α → β ) → γ )).

Aufgrund der Struktur dieser Aussage kann man ¬Δ als die Reduktion ausdrücken, ≥/⌽α β γbei der ≥ ← implementiert. Dies führt zu der Antwort, die ich gerade erkläre.

Pyth, 11 Bytes

!%|F_jQ*TT4

Dieses vollständige Programm liest STDIN aus und gibt True für Schaltjahre und False für andere aus.

Vielen Dank an @Jakube, der Pyth vorgeschlagen und im Grunde meinen CJam-Code portiert hat.

Überprüfen Sie die Testfälle selbst im Pyth Compiler / Executor .

Wie es funktioniert

     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 Bytes

rS+2m<~e|4%!

Dieses vollständige Programm liest aus STDIN und gibt 1 für Schaltjahre und 0 für andere aus.

Überprüfen Sie die Testfälle selbst im CJam-Interpreter .

Wie es funktioniert

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 Zeichen

Die Standardregel ist, dass yein Schaltjahr ist, wenn 4 dividiert yund entweder 100 nicht dividiert yoder 400 dividiert y. In Code,

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

100 und 400 sind nicht erforderlich. Stattdessen reicht es aus, zu überprüfen, ob 16 oder 4 y dividieren, wobei 16 ausgewählt wird, wenn 25 y dividiert, andernfalls 4. Golfen wird das

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

Eine Javascript-Funktion, die dies implementiert, ist 21 Zeichen lang:

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

Perl, 28 26 Zeichen

Gleiche Idee, aber in Perl.

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

Führen Sie mit den -lpOptionen. Zum Beispiel,

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

Wenn der Test als Eingabe festgelegt ist, wird dies erzeugt

1936
y
1805
n
1900
n
2272
y
2400
y

Pip , 13 Bytes

Dieser war interessanter als es auf den ersten Blick erschien. Es dauerte ein bisschen, aber ich konnte endlich die langen Verweise auf 400mit 4und die hVariable (= 100) ersetzen .

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

Ausgaben 1für Schaltjahr, 0für Nichtschaltjahr. Erläuterung:

               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 Bytes

xFm!%Q^d2[2TyT

Viel zu einfach. Probieren Sie es online aus: Vorführ- oder Testgeschirr

edit: Verpasst, dass du Truthy / Falsy-Werte statt drucken kannst n/y. -4 Byte

edit 2: Verwendete die Quadratwurzelidee von Martin. -1 Byte

Erläuterung

                 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

Regex, 83 62 38

Vielen Dank an Toby für die Tipps zum Kombinieren der beiden Hälften des Regex.

Wenn wir uns nur auf den Bereich 1801..2400 konzentrieren und davon ausgehen, dass es sich bei der Eingabe um Ganzzahlen handelt:

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

Test in Ruby ( ^= \Aund $= \Zweil Ruby) für den gewünschten Bereich:

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

(Bonus) für etwas, das nicht nur für 1801..2400 funktionieren sollte, sondern für jedes nicht negative Jahr:

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

Test in Ruby ( ^= \Aund $= \Zweil Ruby) für die ersten 100000 Jahre:

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

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

Golfen: !(y%100<1&&y%400||y%4)(hauptsächlich nach dem Gesetz von De Morgans )

Eine Funktion, die die Regel implementiert:

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

Ein Test (in Firefox ausgeführt), um sicherzugehen:

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

Da TI-BASIC tokenisiert ist, ist es bei einfachen mathematischen Herausforderungen oft wettbewerbsfähig, aber nicht bei diesem, da es keinen "teilbaren" Befehl gibt. Vielleicht ist es doch so, aber das ist immer noch länger als CJam und Pyth.

Dies erfolgt nach der Methode von David Hammond.

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

Alter Code bei 16 Bytes:

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

Ungolfed:

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

fPart(ist "Bruchteil"; Potenzierung hat Vorrang vor Division. In TI-BASIC sind enge Parens optional.

Ich verwende das undokumentierte Verhalten des sub(Befehls, das normalerweise zum Abrufen einer Teilzeichenfolge verwendet wird: Wenn das Argument eine Zahl anstelle einer Zeichenfolge ist, dividiert es die Zahl durch 100. Es funktioniert mit einem Taschenrechner der Serie TI-83 oder 84.

20 -> 17 durch Neuanordnen des Codes, um das Entfernen von eng beieinander liegenden Elementen zu ermöglichen; 17 -> 16 durch Ersetzen von 400 durch 16; 16 -> 13 nach der Idee von David Hammond.

Stackylogic, 226 Bytes (nicht konkurrierend)

Ja, das ist richtig. Ich habe ein Programm in Stackylogic (Nicht-TC) erstellt, das von Helka Homba für die hier zu findende Herausforderung erfunden wurde . Dies erfolgt nach der Herausforderung, also ohne Konkurrenz.

Stackylogic hat nur eine Binäreingabe, daher müssen 10 (oder mehr, alle Ziffern werden ignoriert) Bit-Binär verwendet werden (niedrigstwertiges Bit wird zuerst eingegeben). Alle Daten außerhalb des angegebenen Bereichs können fehlschlagen, da lediglich überprüft wird, wie die eingegebene Zahl lautet: Es werden keine unnötigen Daten erfasst

Dies ist nicht nur meine erste Herausforderung mit Stackylogic, sondern überhaupt die erste Herausforderung mit Stackylogic.

Mach dich bereit für dieses Chaos:

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

Das hat so lange gedauert, weil Stackylogic die verwirrendste Sprache ist, die mir begegnet ist, und extrem unleserlich: Sie müssen wissen, wie der Rest des Programms ausgeführt wurde, bevor Sie den aktuellen Abschnitt lesen können, der gerade bearbeitet wird. Ich musste sogar Leerzeichen für die Lesbarkeit beim Erstellen hinzufügen.

Magere Erklärung

Dies ist eine einfache Erklärung dessen, was es tut.

Stackylogic hat keine mathematischen Funktionen, was dies erschwert. Ich musste das meiste fest codieren, um zu überprüfen, ob es sich um eine bestimmte Nummer handelte.

Erstens führt dieses Programm ein NOR der niedrigstwertigen Bits durch und verwirft sie dabei. Dies bedeutet, dass, wenn es durch 4 teilbar ist, zum Hauptteil des Programms übergegangen wird, andernfalls wird 0 ausgegeben.

Zweitens wird der Zeiger auf das Labyrinth der Stackylogic übertragen. Wenn die nächsten beiden Bits Null sind, wird sofort 1 ausgegeben (da es dann durch 16 teilbar ist und somit trotz aller anderen Bedingungen ein Schaltjahr) In diesem Fall wird geprüft, ob es sich nicht um eine durch 4 teilbare Zahl handelt, sondern um ein Schaltjahr zwischen 1801 und 2400.

Im Detail zu erklären, würde bedeuten, diesen Beitrag um ein Vielfaches länger zu machen als er bereits ist

IBM System Z-Assembler - 56 Byte.

(96 Byte der Quelle. Vorher 712 384 202 Byte der Quelle, 168 Byte ausführbar).

Kleinere Version noch. Speichert keine Anruferregister mehr, ändert den Literalspeicher und den Adressierungsmodus.

 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 

Neue Version. Dies wird mit einem S0C1 ABENDEN, wenn es ein Schaltjahr ist, und eine Schleife, wenn es nicht ist. Hoffentlich erfüllt dies die Anforderung, das Ergebnis anzugeben.

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, also nicht die kürzeste (obwohl es sein kann, dass wir uns einmal den tatsächlich ausgeführten Code und die Interpretergröße ansehen ...)

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  

Ausgabe:

BEENDEN SIE S0C1 für ein Schaltjahr, S222 (wenn die CPU-Zeit abgelaufen ist), wenn nicht.

1936 Y 1805 N 1900 N 2272 Y 2400 Y

(wenn mehrmals ausgeführt)

CJam, 18 16 Bytes

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

Gibt 1(wahr) für Schaltjahre und 0(falsch) sonst.

Führen Sie hier alle Testfälle aus.

Erläuterung

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 Bytes, 17 Zeichen

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

Verwendet 17 Zeichen, aber 27 Bytes. Danke an @alephalpha für den Tipp. Beachten Sie, dass die vertikalen Balken für Teilungen tatsächlich U + 2223 sind. Das <U+F523>sollte durch das entsprechende Zeichen ersetzt werden.

R 29

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

Testlauf

> !(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

Ich kann es kürzer machen, aber dieser hält sich ordentlich an 'char'-Typen, ohne das Argument zu analysieren (zB mit atoi):

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

Sie muss mit einem Namen von 4 Zeichen Länge aufgerufen werden, da standardmäßig davon ausgegangen wird, dass Argumente unmittelbar auf den Programmnamen folgen, getrennt durch NULs. Außerdem wird davon ausgegangen, dass das einzelne Argument in ASCII codiert ist und kein führendes Leerzeichen enthält.

Erläuterung:

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+9ist die Position der Zehnerstelle in v[1]+2.

Wenn die Zeichen 'Zehn' und 'Einheiten' zu 96 addieren, enden wir mit, sichern Sie 00also zwei Zeichen, sodass die Zeichen 'Zehn' und 'Einheiten' auf die Jahrhundertzahl verweisen.

Jetzt xor 'units' mit dem doppelten 'tens', mod 4. Dies funktioniert, weil 10==±2 mod 4das untere Bit der 'tens' nur Bit 1 der 'units' umschalten kann. Wir verwenden das Ergebnis als Index in unserer Resttabelle und drucken ynur, wenn das modulare Ergebnis Null ist.

Befunge -98, (41 Bytes)

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

Einfachheit ist großartig.

sed, 55

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

• Die erste Zeile teilt die exakten Jahrhunderte durch 100.
• Die zweite Zeile gibt 'N' für ungerade Ziffern, 'y' für 4s und 'n' für Nicht-4s.
• Dritte Zeile vertauscht 'y' und 'n', wenn es eine ungerade vorletzte Ziffer gibt (weil 10 2 mod 4 ist)
• Letzte Zeile löscht alle bis auf das letzte Zeichen

Beachten Sie, dass Nicht-Schaltjahre möglicherweise als noder Nabhängig davon gedruckt werden, ob sie gerade oder ungerade sind. Ich halte dies für eine kreative Interpretation der Regel, die Alternativen zu "Ja" und "Nein" zulässt, ohne dass angegeben wird, dass sie konsistent sein müssen.

Python2 - 37

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

Beachten Sie, dass es sich bei if aum eine nicht negative Ganzzahl a<1handelt not bool(a). Der letzte <1wandelt den Ausdruck in den Klammern effektiv in einen Booleschen Wert um und negiert das Ergebnis.

Wenn Sie die Funktion gauf eine Ganzzahl nzwischen 1801 und 2400 anwenden, wird zurückgegeben, Truewenn nes sich um ein Schaltjahr handelt, Falseandernfalls.

KDB (Q), 27 Bytes

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

Erläuterung

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

Prüfung

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

Julia, 30 28 Bytes

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

Dadurch wird eine unbenannte Funktion erstellt, die ein ganzzahliges Argument akzeptiert und einen booleschen Wert zurückgibt. Um es zu nennen, geben Sie ihm einen Namen, z f=y->....

Ungolfed:

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

Beispiel:

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

PHP - 45 Bytes

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

Eigentlich nichts Besonderes, nur das Typ-Jonglieren zu missbrauchen.

C #, 23 Bytes

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

Probieren Sie es online!

Vollständige Quelle, einschließlich Testfällen:

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 Bytes

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

Wandbox

T-SQL 37 22 Bytes

Dank BradCs Kommentar 15 Bytes gespart.

Die übliche fest codierte Variable mangels a stdin.

z.B

DECLARE @ NVARCHAR(4) = '2016'

Dann lautet die Lösung:

PRINT ISDATE(@+'0229')

Java 8, 49 45 22 20 Bytes

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

-2 Bytes dank @ OlivierGrégoire .

Probieren Sie es online aus.

Einige 22-Byte-Lösungen:

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

Probieren Sie es online aus.

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

Probieren Sie es online aus.

java.time.Year::isLeap

Probieren Sie es online aus.

Erläuterung:

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 Bytes

f i=gcd 80i>gcd 50i

Probieren Sie es online!

Javascript ES6, 32, 29, 26

Jede der folgenden Zeilen funktioniert:

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 Bytes

Übernimmt die Eingabe von stdin mit oder ohne nachfolgende Leerzeichen / Zeilenumbrüche. Funktioniert nur auf kleinen Endian-Rechnern (ja, so wie heutzutage jeder BE betreibt). Ausgänge Y oder N.

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

Erläuterung

Ungolfed:

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

Zuerst scanfliest das Jahr als eine ganze Zahl in y. Dann wird y mit 4 oder 400 moduliert, je nachdem, ob das Jahr durch 100 teilbar ist. Wenn der Rest Null ist, wird der ASCII-Code für Y y zugewiesen, andernfalls wird der ASCII-Code für N abgerufen. Der Wert von y ist jetzt 0x000000??, wo 0x??ist das zugewiesene Zeichen. Wenn Sie sich auf einem Little-Endian-Computer befinden, wird dies im Speicher als gespeichert ?? 00 00 00. Dies ist eine mit NULL abgeschlossene C-Zeichenfolge, die nur die zugewiesenen Zeichen enthält. Die Adresse von y wird an Puts übergeben und das Zeichen wird gedruckt (mit einer nachgestellten Zeile).

PowerShell, 31 Byte

Ich freue mich zu sagen, dass ich dies kürzer als das eingebaute Golf gespielt habe!

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

Ausgänge für Schaltjahre wahr und ansonsten falsch.

Eingebaut:

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

Wollte ich die Aussage "Dem Benutzer klar sagen, ob es sich um ein Schaltjahr handelt oder nicht" strecken und etwas anderes tun, könnte ich 3 Bytes einsparen und Folgendes verwenden:

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

Diese Ausgabe erfolgt 0für Schaltjahre und 1 oder höher für Nicht-Schaltjahre, was mir nicht gefällt, da ich es vorziehen würde, für Schaltjahre einen normaleren Wahrheitswert zurückzugeben.

LOLCODE, 228 202 159 Bytes

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

Ungolfed:

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

In Python ungolfed, weil LOLCODE verwirrend ist:

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