Questa sfida è abbastanza semplice. Riceverai un input che sarà un anno dal 1801 al 2400, e output se è un anno bisestile o meno.

Il tuo input non avrà newline o spazi finali:

1954

Verrà emesso in qualsiasi modo che ti piace che dice chiaramente all'utente se è o non è un anno bisestile (accetterò y o n per sì / no)

È possibile ottenere un elenco degli anni bisestili qui: http://kalender-365.de/leap-years.php Vorrei notare che gli anni bisestili non sono sempre quattro anni sempre. Il 1896 è un anno bisestile, ma il 1900 no. Gli anni che seguono questo "salto" sono:

1900
2100
2200
2300

Casi test:

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

EDIT: si basa su un calendario gregoriano standard: http://www.epochconverter.com/date-and-time/daynumbers-by-year.php

APL, 16 14 12 caratteri

Restituisce 0per un anno bisestile, 1per un anno non bisestile.

≥/⌽×4 25 4⊤⎕

Prova questa soluzione su tryapl.org . Si noti che ho modificato la soluzione a dfn in {≥/⌽×4 25 4⊤⍵}quanto tryapl.com non supporta ⎕( accetta l'input dell'utente). Nota che ⎕è una casella vuota, non un carattere mancante.

La stessa soluzione in J:

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

Spiegazione

Dyadic ⊤(codifica) rappresenta il suo argomento destro nella base specificata dal suo argomento sinistro. Uso la base 4 25 4in questa soluzione. Questo rappresenta l'anno y come un polinomio

y mod 400 = 100 a + 4 b + c  dove b <100 ec <4.

Consenti alle proposizioni α, β e γ di rappresentare se a, b e c sono diverse da zero: la proposizione γ è falsa se y è divisibile per 4, β ∧ γ è falsa se y è divisibile per 100 e α ∧ β ∧ γ è falso se y è divisibile per 400.

Una tabella di verità (che *rappresenta "non importa") dove proposizione Δ rappresenta se y è un anno bisestile ottiene:

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

La seguente dichiarazione esprime Δ in α , β e γ :

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

A causa della struttura di questa affermazione, si può esprimere ¬Δ come riduzione ≥/⌽α β γdove ≥ implementa ←. Questo porta alla risposta che sto spiegando proprio ora.

Pyth, 11 byte

!%|F_jQ*TT4

Questo programma completo legge da STDIN e stampa True per gli anni bisestili e False in caso contrario.

Grazie a @Jakube per aver suggerito Pyth e sostanzialmente il porting del mio codice CJam.

Verifica tu stesso i casi di test in Pyth Compiler / Executor .

Come funziona

     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 byte

rS+2m<~e|4%!

Questo programma completo legge da STDIN e stampa 1 per anni bisestili e 0 altrimenti.

Verifica tu stesso i casi di test nell'interprete CJam .

Come funziona

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 caratteri

La regola standard è che yè un anno bisestile se 4 divide ye se 100 non si divide yo 400 si divide y. Nel codice,

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

Non è necessario per quei 100 e 400. Invece è sufficiente verificare se 16 o 4 divide y, con 16 scelti se 25 divide y, 4 altrimenti. Golfato, questo diventa

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

Una funzione javascript che implementa questa lunghezza è di 21 caratteri:

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

Perl, 28 26 caratteri

Stessa idea, ma in perl.

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

Esegui utilizzando le -lpopzioni. Per esempio,

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

Con il test impostato come input, questo produce

1936
y
1805
n
1900
n
2272
y
2400
y

Pip , 13 byte

Questo è stato più interessante di quanto sembrasse a prima vista. Ci sono voluti alcuni tentativi, ma alla fine sono stato in grado di sostituire quei lunghi riferimenti a 400con 4e la hvariabile (= 100).

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

Uscite 1per l'anno bisestile, 0per l' anno non bisestile. Spiegazione:

               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 byte

xFm!%Q^d2[2TyT

Troppo facile. Provalo online: cablaggio dimostrativo o di prova

modifica: Perso, che è possibile stampare i valori Verità / Falsi, anziché n/y. -4 byte

modifica 2: usata l'idea della radice quadrata di Martin. -1 byte

Spiegazione

                 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

Grazie a Toby per i suggerimenti su come combinare entrambe le metà del regex.

Se ci concentriamo solo sull'intervallo 1801..2400 e supponiamo che l'input sia un numero intero:

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

Test in Ruby ( ^= \Ae $= \Zbecause Ruby) per l'intervallo desiderato:

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) per qualcosa che dovrebbe funzionare non solo per 1801..2400, ma per qualsiasi anno non negativo:

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

Test in Ruby ( ^= \Aand $= \Zbecause Ruby) per i primi 100000 anni:

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 regola: (y%4==0) && (y%100!=0 || y%400==0)

Golf: !(y%100<1&&y%400||y%4)(principalmente usando la legge di De Morgans )

Una funzione che implementa la regola:

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

Un test (eseguito su Firefox) solo per essere sicuri:

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

Poiché è tokenizzato, TI-BASIC è spesso competitivo in semplici sfide matematiche, ma non in questo perché non esiste un comando "divisibile". Forse è dopo tutto, ma questo è ancora più lungo di CJam e Pyth.

Questo utilizza il metodo di David Hammond.

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

Vecchio codice a 16 byte:

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(è "parte frazionaria"; l'espiazione ha una precedenza maggiore rispetto alla divisione. In TI-BASIC, i parentesi ravvicinati sono opzionali.

Uso un comportamento non documentato del sub(comando, solitamente utilizzato per ottenere una sottostringa: quando il suo argomento è un numero anziché una stringa, divide il numero per 100. Funzionerà su una calcolatrice della serie TI-83 o 84.

20 -> 17 riorganizzando il codice per consentire la rimozione di parentesi ravvicinate; 17 -> 16 sostituendo 400 con 16; 16 -> 13 usando l'idea di David Hammond.

Stackylogic, 226 byte (non concorrenti)

Si è giusto. Ho realizzato un programma in Stackylogic (non TC), che è stato inventato da Helka Homba, per la sfida trovata qui . Questo è fatto dopo la sfida, quindi non competitivo.

Stackylogic ha solo input binario, quindi devono essere usati 10 (o più cifre, verranno ignorate altre cifre) bit binario (il bit meno significativo inserito per primo). Eventuali date al di fuori dell'intervallo specificato potrebbero non riuscire, poiché controlla semplicemente qual è il numero immesso: non copre le date non necessarie

Questa non è solo la mia prima sfida con stackylogic, ma la prima sfida con stackylogic.

Preparati per questo pasticcio:

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

Mi ci è voluto tanto tempo perché Stackylogic è il linguaggio più confuso che abbia mai incontrato ed estremamente illeggibile: devi sapere come è stato eseguito il resto del programma prima di poter leggere la sezione corrente in fase di modifica. Ho anche dovuto aggiungere spazi per la leggibilità durante la creazione.

Magra spiegazione

Questa è una semplice spiegazione di ciò che fa.

Stackylogic non ha alcuna funzione matematica, quindi ciò ha reso questo più difficile. Ho dovuto hardcodificare la maggior parte di esso, per verificare se fosse un numero specifico.

Innanzitutto, questo programma eseguirà una NOR dei bit meno significativi, scartandoli nel processo. questo significa che se è divisibile per 4, passerà alla parte principale del programma, altrimenti emetterà 0.

In secondo luogo, il puntatore viene trasferito nel labirinto dello stackylogic, da qui, se i due bit successivi sono zero, emetterà immediatamente 1 (poiché è quindi divisibile per 16, e quindi un anno bisestile nonostante qualsiasi altra condizione), altro saggio controllerà se non è uno dei numeri che è divisibile per 4 ma non un anno bisestile, tra il 1801 e il 2400.

Per spiegare in dettaglio, implicherebbe rendere questo post molte volte più lungo di quanto non sia già

Assemblatore IBM System Z - 56 byte.

(96 byte di origine. Precedentemente 712 384 202 byte di origine, eseguibile 168 byte).

Versione più piccola ancora. Non salva più i registri del chiamante, passa alla memoria letterale, cambia la modalità di indirizzamento.

 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 

Nuova versione. Questo arrenderà con un S0C1 se è un anno bisestile e andrà in loop se non lo è. Speriamo che soddisfi il requisito di indicare il risultato.

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, quindi non il più breve (anche se potrebbe essere una volta che guardiamo il codice effettivamente eseguito più la dimensione dell'interprete ...)

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  

Produzione:

ABEND S0C1 per un anno bisestile, S222 (quando il tempo della CPU è scaduto) in caso contrario.

1936 A 1805 N 1900 N 2272 A 2400 A

(se eseguito più volte)

CJam, 18 16 byte

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

Fornisce 1(verità) per anni bisestili e 0(falsa) altrimenti.

Esegui tutti i casi di test qui.

Spiegazione

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 byte, 17 caratteri

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

Utilizza 17 caratteri, ma 27 byte. Grazie a @alephalpha per l'informazione. Si noti che le barre verticali sono in realtà U + 2223 per le divisioni. Il <U+F523>deve essere sostituito con il carattere corrispondente.

R, 29

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

Prova

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

Posso fare più breve, ma questo si attacca perfettamente ai tipi "char", senza analizzare l'argomento (ad esempio con atoi):

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

Deve essere invocato con un nome di 4 caratteri, perché presuppone che gli argomenti seguano immediatamente il nome del programma, separati da NUL. Inoltre, presuppone che il singolo argomento sia codificato in ASCII e non abbia spazio iniziale.

Spiegazione:

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è la posizione della cifra "decine" in v[1]+2.

Se i caratteri "decine" e "unità" si sommano a 96, si finisce con 00, quindi si esegue il backup di due caratteri, in modo che "decine" e "unità" puntino al numero del secolo.

Ora xor 'unità' con il doppio delle 'decine', mod 4. Questo funziona perché 10==±2 mod 4, quindi il bit inferiore delle 'decine' può semplicemente attivare il bit 1 delle 'unità'. Usiamo il risultato come indice nella nostra tabella dei resti, stampando ysolo se il risultato modulare è zero.

Befunge -98, (41 byte)

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

La semplicità è fantastica.

sed, 55

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

• La prima riga divide i secoli esatti per 100.
• La seconda riga fornisce "N" a cifre dispari, da "y" a 4 secondi e "n" a non 4 secondi.
• La terza riga scambia 'y' e 'n' se c'è una cifra penultima dispari (perché 10 è 2 mod 4)
• La linea finale cancella tutto tranne l'ultimo personaggio

Si noti che gli anni non bisestili possono essere stampati come no a Nseconda che siano pari o dispari. Considero questa un'interpretazione creativa della regola che consente alle alternative di "sì" e "no" senza specificare che devono essere coerenti.

Python2 - 37

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

Nota che se aè un numero intero non negativo, allora a<1è un modo breve di scrivere not bool(a). L'ultimo <1converte quindi efficacemente l'espressione tra parentesi in un valore booleano e annulla il risultato.

L'applicazione della funzione ga un numero intero ncompreso tra 1801 e 2400 restituirà Truese si ntratta di un anno bisestile e in caso Falsecontrario.

KDB (Q), 27 byte

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

Spiegazione

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

Test

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

Julia, 30 28 byte

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

Ciò crea una funzione senza nome che accetta un argomento intero e restituisce un valore booleano. Per chiamarlo, dagli un nome, ad es f=y->....

Ungolfed:

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

Esempio:

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

PHP - 45 byte

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

Niente di veramente speciale, solo abusare della giocoleria di tipo.

C #, 23 byte

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

Provalo online!

Fonte completa, compresi i casi di 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 byte

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

Wandbox

T-SQL 37 22 byte

Risparmiato 15 byte grazie al commento di BradC.

La solita variabile hardcoded per mancanza di a stdin.

per esempio

DECLARE @ NVARCHAR(4) = '2016'

Quindi la soluzione è:

PRINT ISDATE(@+'0229')

Java 8, 49 45 22 20 byte

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

-2 byte grazie a @ OlivierGrégoire .

Provalo online.

Alcune soluzioni da 22 byte:

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

Provalo online.

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

Provalo online.

java.time.Year::isLeap

Provalo online.

Spiegazione:

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 byte

f i=gcd 80i>gcd 50i

Provalo online!

Javascript ES6, 32, 29, 26

Una delle seguenti linee funziona:

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 byte

Prende l'input da stdin, con o senza spazi finali / newline. Funziona solo su macchine little endian (sì, come tutti sono su BE in questi giorni). Uscite Y o N.

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

Spiegazione

Ungolfed:

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

Innanzitutto, scanflegge l'anno come numero intero in y. Quindi, y viene modulo con 4 o 400 a seconda che l'anno sia divisibile per 100. Se il resto è zero, il codice ASCII per Y viene assegnato a y, altrimenti ottiene il codice ASCII per N. Il valore di y è ora 0x000000??, dov'è 0x??il personaggio assegnato. Essere su una macchina little-endian, in memoria questo è memorizzato come ?? 00 00 00. Questa è una stringa C terminata con NULL, contenente solo i caratteri assegnati. L'indirizzo di y viene passato a put e il carattere viene stampato (con una nuova riga finale).

PowerShell, 31 byte

Sono entusiasta di dire che ho giocato a golf più corto di quello incorporato!

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

Produce vero per anni bisestili e falso altrimenti.

builtin:

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

Tuttavia, se volessi estendere la frase "dice chiaramente all'utente se è o non è un anno bisestile" e fare qualcosa di non standard, potrei salvare 3 byte e usare:

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

Questo produce output 0per gli anni bisestili e 1 o più per gli anni non bisestili, cosa che non mi piace poiché preferirei restituire un valore di verità più standard per gli anni bisestili.

LOLCODE, 228 202 159 byte

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, perché LOLCODE è confuso:

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