Ce défi est assez simple. Vous allez prendre une entrée qui sera une année de 1801 à 2400 et une sortie si c'est une année bissextile ou non.

Votre entrée n'aura pas de nouvelles lignes ni d'espaces de fin:

1954

Vous allez sortir de la manière que vous aimez qui indique clairement à l'utilisateur s'il s'agit ou non d'une année bissextile (j'accepterai y ou n pour oui / non)

Vous pouvez obtenir une liste des années bissextiles ici: http://kalender-365.de/leap-years.php Je ferais remarquer que les années bissextiles ne sont pas toujours de quatre ans. 1896 est une année bissextile, mais 1900 ne l’est pas. Les années qui suivent ce "skip" sont:

1900
2100
2200
2300

Cas de test:

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

EDIT: Ceci est basé sur un calendrier Grégorien standard: http://www.epochconverter.com/date-and-time/daynumbers-by-year.php

APL, 16 14 12 caractères

Retours 0pour une année bissextile, 1pour une année non bissextile.

≥/⌽×4 25 4⊤⎕

Essayez cette solution sur tryapl.org . Notez que j'ai changé la solution en dfn {≥/⌽×4 25 4⊤⍵}car tryapl.com ne prend pas en charge ⎕(prendre les entrées de l'utilisateur). Notez que ⎕c'est une case vide, pas un caractère manquant.

La même solution en J:

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

Explication

Dyadic ⊤(encode) représente son argument de droite dans la base spécifiée par son argument de gauche. J'utilise base 4 25 4dans cette solution. Ceci représente l'année y comme un polynôme

y mod 400 = 100 a + 4 b + c  où b <100 et c <4.

Soit les propositions α, β et γ si a, b et c sont non nuls: La proposition γ est fausse si y est divisible par 4, β ∧ γ est fausse si y est divisible par 100 et α ∧ β ∧ γ est false si y est divisable par 400.

Une table de vérité ( *représentant «peu importe») où la proposition Δ représente si y est une année bissextile obtient:

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

L’énoncé suivant exprime Δ dans α , β et γ :

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

En raison de la structure de cette déclaration, on peut exprimer ¬Δ par la réduction ≥/⌽α β γoù ≥ implémente ←. Cela conduit à la réponse que j'explique en ce moment.

Pyth, 11 octets

!%|F_jQ*TT4

Ce programme complet est lu dans STDIN et affiche Vrai pour les années bissextiles et Faux dans le cas contraire.

Merci à @Jakube d’avoir suggéré Pyth et porté mon code CJam.

Vérifiez les cas de test vous-même dans le compilateur / exécuteur Pyth .

Comment ça marche

     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 octets

rS+2m<~e|4%!

Ce programme complet est lu dans STDIN et en affiche 1 pour les années bissextiles et 0 sinon.

Vérifiez les cas de test vous-même dans l' interpréteur CJam .

Comment ça marche

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 caractères

La règle standard est qu’il ys’agit d’une année bissextile si 4 divisent yet si 100 ne divise pas you 400 ne divise pas y. Dans du code,

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

100 et 400 ne sont pas nécessaires. Au lieu de cela, il suffit de vérifier si 16 ou 4 divise y, avec 16 choisi si 25 divise y, 4 sinon. Golfé, cela devient

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

Une fonction javascript qui implémente ceci est composée de 21 caractères:

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

Perl, 28 26 caractères

Même idée, mais en Perl.

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

Exécuter en utilisant les -lpoptions. Par exemple,

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

Avec le test configuré en entrée, cela produit

1936
y
1805
n
1900
n
2272
y
2400
y

Pip , 13 octets

Celui-ci était plus intéressant qu'il ne parut au début. Cela a pris du temps, mais j'ai finalement pu remplacer ces longues références à 400with 4et à la hvariable (= 100).

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

Sorties 1pour l'année bissextile, 0pour l' année non bissextile. Explication:

               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 octets

xFm!%Q^d2[2TyT

Bien trop facile. Essayez-le en ligne: démonstration ou test de harnais

edit: Missed, que vous pouvez imprimer les valeurs Truthy / Falsy au lieu de n/y. -4 octets

edit 2: Utilisé l'idée de racine carrée de Martin. -1 octet

Explication

                 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

Merci à Toby pour ses conseils sur la combinaison des deux moitiés de la regex.

Si nous nous concentrons uniquement sur la plage 1801..2400 et supposons que les entrées sont des entiers:

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

Testez en Ruby ( ^= \Aet $= \Zparce que Ruby) pour la plage souhaitée:

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) pour quelque chose qui devrait fonctionner non seulement pour 1801..2400, mais pour toute année non négative:

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

Test en Ruby ( ^= \Aet $= \Zparce que Ruby) pour les 100 000 premières années:

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

La règle: (y%4==0) && (y%100!=0 || y%400==0)

Golfé: !(y%100<1&&y%400||y%4)(utilisant principalement la loi de De Morgans )

Une fonction implémentant la règle:

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

Un test (exécuté dans Firefox) juste pour être sûr:

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

Du fait qu’il est sous forme de jetons, TI-BASIC est souvent compétitif face aux défis mathématiques simples, mais pas à celui-ci car il n’ya pas de commande "divisible". Peut-être que c'est après tout, mais c'est encore plus long que CJam et Pyth.

Ceci utilise la méthode de David Hammond.

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

Ancien code à 16 octets:

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(est "partie fractionnaire"; l'exponentiation a une priorité supérieure à la division. Dans TI-BASIC, les proches parents sont facultatifs.

J'utilise un comportement non documenté de la sub(commande, généralement utilisé pour obtenir une sous-chaîne: lorsque son argument est un nombre au lieu d'une chaîne, il divise le nombre par 100. Il fonctionnera sur une calculatrice de la TI-83 ou de la série 84.

20 -> 17 en réarrangeant le code pour permettre le retrait des proches parents; 17 -> 16 en remplaçant 400 par 16; 16 -> 13 en utilisant l'idée de David Hammond.

Stackylogic, 226 octets (non concurrents)

Oui, c'est correcte. J'ai réalisé un programme en Stackylogic (non-TC), inventé par Helka Homba, pour le défi relevé ici . Ceci est fait après le challenge, donc non compétitif.

Stackylogic n’ayant qu’une entrée binaire, il faut utiliser 10 bits (ou plus, tous les chiffres étant ignorés). Le bit binaire doit être utilisé (le bit le moins significatif entré en premier). Toutes les dates en dehors de la plage spécifiée peuvent échouer, car il vérifie simplement le nombre entré: il ne couvre pas les dates inutiles

Non seulement c'est mon premier défi avec stackylogic, mais le premier défi avec stackylogic du tout.

Préparez-vous pour ce gâchis:

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

Cela m'a pris si longtemps, car Stackylogic est le langage le plus déroutant que j'ai rencontré et extrêmement illisible: vous devez savoir comment le reste du programme a été exécuté avant de pouvoir lire la section en cours d'édition. J'ai même dû ajouter des espaces pour la lisibilité lors de la création.

Explication maigre

Ceci est une explication simple de ce qu’il fait.

Stackylogic n’a aucune fonction mathématique, ce qui a rendu cela plus difficile. J'ai dû coder la plupart du temps, pour vérifier s'il s'agissait d'un numéro spécifique.

Premièrement, ce programme fera un NOR des bits les moins significatifs, en les rejetant au cours du processus. cela signifie que s'il est divisible par 4, il passera à la partie principale du programme, sinon la sortie 0.

Deuxièmement, le pointeur est reporté dans le labyrinthe de stackylogic. À partir de là, si les deux bits suivants sont nuls, il affichera instantanément 1 (car il est divisible par 16, et donc une année bissextile en dépit de toute autre condition), autre sage, il vérifiera si aucun des nombres n'est divisible par 4 mais pas une année bissextile, entre 1801 et 2400.

Pour expliquer en détail, impliquerait de faire ce poste plusieurs fois plus long qu'il ne l'est déjà

Assembleur IBM System Z - 56 octets.

(96 octets de la source. Auparavant 712 384 202 octets de la source, 168 octets exécutables).

Version plus petite encore. N'enregistre plus les registres de l'appelant, les modifications apportées au stockage littéral, le mode d'adressage modifié.

 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 

Nouvelle version. Cela ABEND avec un S0C1 s’il s’agit d’une année bissextile et une boucle si ce n’est pas le cas. Espérons que cela remplisse l'exigence d'indiquer le résultat.

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, donc pas le plus court (bien que cela puisse être une fois que nous examinons le code réellement exécuté plus la taille de l'interpréteur ...)

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  

Sortie:

ABENDER S0C1 pour une année bissextile, S222 (lorsque le temps CPU est écoulé) sinon.

1936 Y 1805 N 1900 N 2272 Y 2400 Y

(lorsqu'il est exécuté plusieurs fois)

CJam, 18 16 octets

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

Donne 1(vérité) pour les années bissextiles et 0(fausseté) autrement.

Exécutez tous les cas de test ici.

Explication

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 octets, 17 caractères

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

Utilise 17 caractères, mais 27 octets. Merci à @alephalpha pour le tuyau. Notez que les barres verticales sont réellement U + 2223 pour les divisions. le<U+F523> devrait être remplacé par le caractère correspondant.

R, 29

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

Essai

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

Je peux faire plus court, mais celui-ci s'en tient parfaitement aux types 'char', sans analyser l'argument (par exemple avec atoi):

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

Il doit être appelé avec un nom long de 4 caractères, car il est généralement admis que les arguments suivent immédiatement le nom du programme, séparés par des NUL. De plus, cela suppose que le seul argument est codé en ASCII et qu’il n’ya pas d’espace au début.

Explication:

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+9est la position du chiffre 'dizaines' dans v[1]+2.

Si les caractères 'dizaines' et 'unités' totalisent 96, nous terminons par 00 , sauvegardons donc deux caractères, de sorte que 'dizaines' et 'unités' désignent le nombre du siècle.

Maintenant, xor "unités" avec deux fois les "dizaines", mod 4. Cela fonctionne parce que 10==±2 mod 4, de sorte que le bit inférieur des "dizaines" peut simplement basculer le bit 1 des "unités". Nous utilisons le résultat comme index dans notre table des restes, en imprimant yuniquement si le résultat modulaire est nul.

Befunge -98, (41 bytes)

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

La simplicité est géniale.

sed, 55

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

• La première ligne divise les siècles exacts par 100.
• La deuxième ligne donne «N» aux chiffres impairs, «y» à 4s et «n» aux non-4.
• La troisième ligne échange "y" et "n" s'il y a un avant-dernier chiffre impair (parce que 10 est 2 mod 4)
• La dernière ligne supprime tout sauf le dernier caractère

Notez que les années non bissextiles peuvent être imprimées comme nou Nselon leur caractère pair ou impair. J’estime qu’il s’agit d’une interprétation créative de la règle qui autorise les alternatives au "oui" et au "non" sans préciser qu’elles doivent être cohérentes.

Python2 - 37

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

Notez que s’il as’agit d’un nombre entier non négatif, la a<1méthode d’écriture est courte not bool(a). Ce dernier <1convertit donc efficacement l'expression entre parenthèses en un booléen et annule le résultat.

L'application de la fonction gà un nombre entier ncompris entre 1801 et 2400 renverra Truesi nest une année bissextile, et Falsesinon.

KDB (Q), 27 octets

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

Explication

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

Tester

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

Julia, 30 28 octets

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

Cela crée une fonction non nommée qui accepte un argument entier et renvoie une valeur booléenne. Pour l'appeler, donnez-lui un nom, par exemple f=y->....

Ungolfed:

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

Exemple:

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

PHP - 45 octets

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

Rien d'aussi spécial, juste d'abuser du jonglage de caractères.

C #, 23 octets

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

Essayez-le en ligne!

Source complète, y compris les cas de test:

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 octets

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

Boîte à baguette

T-SQL 37 22 octets

Sauvegardé 15 octets grâce au commentaire de BradC.

La variable habituelle codée en dur en l'absence de stdin.

par exemple

DECLARE @ NVARCHAR(4) = '2016'

Alors la solution est:

PRINT ISDATE(@+'0229')

Java 8, 49 45 22 20 octets

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

-2 octets grâce à @ OlivierGrégoire .

Essayez-le en ligne.

Quelques solutions sur 22 octets:

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

Essayez-le en ligne.

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

Essayez-le en ligne.

java.time.Year::isLeap

Essayez-le en ligne.

Explication:

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 octets

f i=gcd 80i>gcd 50i

Essayez-le en ligne!

Javascript ES6, 32, 29, 26

Une des lignes suivantes fonctionne:

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 octets

Prend l'entrée de stdin, avec ou sans espaces de fin / nouvelle ligne. Ne fonctionne que sur des petites machines endian (oui, comme tout le monde est sur BE ces jours-ci). Sorties Y ou N.

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

Explication

Ungolfed:

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

Tout d'abord, scanflit l'année comme un entier dans y. Ensuite, y est modulé avec 4 ou 400 selon que l’année est divisible par 100. Si le reste est égal à zéro, le code ASCII de Y est attribué à y, sinon il obtient le code ASCII de N. La valeur de y est maintenant 0x000000??, où 0x??est le caractère attribué. Étant sur une machine little-endian, cela est enregistré en mémoire ?? 00 00 00. C'est une chaîne C terminée par NULL, contenant uniquement les caractères attribués. L'adresse de y est transmise aux options de vente et le caractère est imprimé (avec une nouvelle ligne).

PowerShell, 31 octets

Je suis enthousiaste à l'idée de dire que j'ai joué au golf plus court que le jeu intégré!

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

Sorties true pour les années bissextiles et false sinon.

Intégré:

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

Cependant, si je voulais élargir la déclaration "indique clairement à l'utilisateur si c'est ou non une année bissextile" et si je fais quelque chose de non standard, je pourrais économiser 3 octets et utiliser:

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

Cette sortie 0pour les années bissextiles et 1 ou plus pour les années non bissextiles, ce que je n'aime pas, car je préférerais obtenir une valeur de vérité plus standard pour les années bissextiles.

LOLCODE, 228 202 159 octets

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

En Python sans golf, parce que LOLCODE est déroutant:

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