Este desafío es bastante simple. Tomará una entrada que será un año de 1801 a 2400, y la salida si es un año bisiesto o no.

Su entrada no tendrá líneas nuevas ni espacios finales:

1954

La salida de la forma que desee le indica claramente al usuario si es o no un año bisiesto (aceptaré yn para sí / no)

Puede obtener una lista de los años bisiestos aquí: http://kalender-365.de/leap-years.php Quisiera señalar que los años bisiestos no siempre son cuatro años. 1896 es un año bisiesto, pero 1900 no lo es. Los años que siguen a este "salto" son:

1900
2100
2200
2300

Casos de prueba:

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

EDITAR: Esto se basa en un calendario gregoriano estándar: http://www.epochconverter.com/date-and-time/daynumbers-by-year.php

APL, 16 14 12 caracteres

Devoluciones 0para un año bisiesto, 1para un año no bisiesto.

≥/⌽×4 25 4⊤⎕

Prueba esta solución en tryapl.org . Tenga en cuenta que he cambiado la solución a la dfn {≥/⌽×4 25 4⊤⍵}ya que tryapl.com no es compatible ⎕(tome la entrada del usuario). Tenga en cuenta que ⎕es un cuadro vacío, no un carácter faltante.

La misma solución en J:

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

Explicación

Dyadic ⊤(codificar) representa su argumento derecho en la base especificada por su argumento izquierdo. Yo uso base 4 25 4en esta solución. Esto representa el año y como polinomio.

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

Deje proposiciones alpha, β, y gamma representan si a, b, y c son no-cero: la Propuesta γ es falsa si y es divisible por 4, β ∧ γ es falso si y es divisible por 100 y alpha ∧ β ∧ γ es decir falso si y es divisible por 400.

Una tabla de verdad (que *representa "no importa") donde la proposición Δ representa si y es un año bisiesto obtiene:

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

La siguiente declaración expresa Δ en α , β y γ :

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

Debido a la estructura de esta declaración, uno puede expresar ¬Δ como la reducción ≥/⌽α β γdonde ≥ implementa ←. Esto lleva a la respuesta que estoy explicando en este momento.

Pyth, 11 bytes

!%|F_jQ*TT4

Este programa completo lee de STDIN e imprime True para los años bisiestos y False de lo contrario.

Gracias a @Jakube por sugerir Pyth y básicamente portar mi código CJam.

Verifique los casos de prueba usted mismo en Pyth Compiler / Executor .

Cómo funciona

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

Este programa completo lee de STDIN e imprime 1 para los años bisiestos y 0 en caso contrario.

Verifique los casos de prueba usted mismo en el intérprete de CJam .

Cómo funciona

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 caracteres

La regla estándar es que yes un año bisiesto si 4 divide yy si 100 no divide yo 400 divide y. En codigo,

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

No hay necesidad de que 100 y 400. En cambio, es suficiente verificar si 16 o 4 divide y, con 16 elegidos si 25 divide y, 4 de lo contrario. Golfizado, esto se convierte

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

Una función de JavaScript que implementa esto tiene 21 caracteres de longitud:

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

Perl, 28 26 caracteres

La misma idea, pero en perl.

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

Ejecuta usando las -lpopciones. Por ejemplo,

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

Con la prueba establecida como entrada, esto produce

1936
y
1805
n
1900
n
2272
y
2400
y

Pip , 13 bytes

Este fue más interesante de lo que parecía al principio. Me tomó un poco de tiempo, pero finalmente pude reemplazar esas largas referencias a y 400con 4la hvariable (= 100).

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

Salidas 1para el año bisiesto, 0para el año no bisiesto. Explicación:

               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

Demasiado fácil. Pruébelo en línea: demostración o prueba de arnés

editar: Perdido, que puede imprimir valores de Verdad / Falsificación, en lugar de n/y. -4 byte

editar 2: Usó la idea de raíz cuadrada de Martin. -1 byte

Explicación

                 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

Gracias a Toby por los consejos sobre la combinación de ambas mitades de la expresión regular.

Si nos centramos solo en el rango 1801..2400 y asumimos que la entrada son enteros:

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

Pruebe en Ruby ( ^= \Ay $= \Zporque Ruby) para el rango deseado:

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

(Bonificación) para algo que debería funcionar no solo para 1801..2400, sino para cualquier año no negativo:

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

Prueba en Ruby ( ^= \Ay $= \Zporque Ruby) durante los primeros 100000 años:

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

Golfizado: !(y%100<1&&y%400||y%4)(principalmente usando la ley de De Morgans )

Una función que implementa la regla:

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

Una prueba (ejecutar en Firefox) solo para estar seguro:

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

Debido a que está tokenizado, TI-BASIC a menudo es competitivo en desafíos matemáticos simples, pero no en este ya que no existe un comando "divisible". Tal vez es después de todo, pero esto aún es más largo que CJam y Pyth.

Esto usa el método de David Hammond.

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

Código antiguo a 16 bytes:

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

Sin golf:

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

fPart(es "parte fraccional"; La exponenciación tiene mayor precedencia que la división. En TI-BASIC, los parentescos cercanos son opcionales.

Utilizo el comportamiento no documentado del sub(comando, que generalmente se usa para obtener una subcadena: cuando su argumento es un número en lugar de una cadena, divide el número por 100. Funcionará en una calculadora de la serie TI-83 u 84.

20 -> 17 reorganizando el código para permitir la eliminación de parentescos cercanos; 17 -> 16 reemplazando 400 con 16; 16 -> 13 usando la idea de David Hammond.

Stackylogic, 226 bytes (no competidor)

Si, eso es correcto. Hice un programa en Stackylogic (no TC), que fue inventado por Helka Homba, para el desafío que se encuentra aquí . Esto se hace después del desafío, por lo que no compite.

Stackylogic solo tiene entrada binaria, por lo que se deben usar 10 bits (o más, se ignorarán más dígitos) bit binario (primero se ingresa el bit menos significativo). Cualquier fecha fuera del rango especificado puede fallar, ya que simplemente comprueba cuál es el número ingresado: no cubre fechas innecesarias

No solo es este mi primer desafío con stackylogic, sino el primer desafío con stackylogic.

Prepárate para este desastre:

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

Me llevó mucho tiempo hacerlo, porque Stackylogic es el lenguaje más confuso que he encontrado y extremadamente ilegible: debes saber cómo se ha ejecutado el resto del programa antes de poder leer la sección actual que se está editando. Incluso tuve que agregar espacios para facilitar la lectura mientras lo creaba.

Explicación pobre

Esta es una explicación simple de lo que hace.

Stackylogic no tiene ninguna función matemática, por lo que esto lo hizo más difícil. Tuve que codificar la mayor parte, para verificar si era un número específico.

Primero, este programa hará un NOR de los bits menos significativos, descartándolos en el proceso. Esto significa que si es divisible por 4, se procederá a la parte principal del programa, de lo contrario salida 0.

En segundo lugar, el puntero se traslada al laberinto de stackylogic, desde aquí, si los siguientes dos bits son cero, generará instantáneamente 1 (ya que es divisible por 16 y, por lo tanto, un año bisiesto a pesar de cualquier otra condición), otro sabiamente verificará si ninguno de los números es divisible por 4 pero no es un año bisiesto, entre 1801 y 2400.

Para explicar en detalle, implicaría hacer esta publicación muchas veces más larga de lo que ya es

Ensamblador IBM System Z - 56 bytes.

(96 bytes de fuente. Anteriormente 712 384 202 bytes de fuente, 168 bytes ejecutables).

Versión más pequeña todavía. Ya no guarda los registros de las personas que llaman, los cambios en el almacenamiento literal, el modo de direccionamiento modificado.

 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 

Nueva versión. Esto ABENDRÁ con un S0C1 si es un año bisiesto, y se repetirá si no lo es. Esperemos que cumpla el requisito de indicar el resultado.

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, entonces no es el más corto (aunque podría ser una vez que veamos el código ejecutado real más el tamaño del intérprete ...)

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  

Salida:

ABENDER S0C1 por un año bisiesto, S222 (cuando se agota el tiempo de CPU) si no.

1936 Y 1805 N 1900 N 2272 Y 2400 Y

(cuando se ejecuta varias veces)

CJam, 18 16 bytes

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

Da 1(verdad) para los años bisiestos y 0(falso) lo contrario.

Ejecute todos los casos de prueba aquí.

Explicación

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 caracteres

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

Utiliza 17 caracteres, pero 27 bytes. Gracias a @alephalpha por el dato. Tenga en cuenta que las barras verticales son en realidad U + 2223 para las divisiones. El <U+F523>debe ser reemplazado con el carácter correspondiente.

R, 29

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

Prueba de funcionamiento

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

Puedo hacerlo más corto, pero este se adhiere perfectamente a los tipos 'char', sin analizar el argumento (por ejemplo, con atoi):

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

Debe invocarse con un nombre de 4 caracteres de largo, ya que supone que los argumentos siguen inmediatamente al nombre del programa, separados por NUL. Además, se supone que el argumento único está codificado en ASCII y no tiene espacio inicial.

Explicación:

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+9es la posición del dígito 'decenas' en v[1]+2.

Si los caracteres 'decenas' y 'unidades' se suman a 96, terminamos 00, así que haga una copia de seguridad de dos caracteres, de modo que 'decenas' y 'unidades' apunten al número del siglo.

Ahora xor 'unidades' con el doble de 'decenas', mod 4. Esto funciona porque 10==±2 mod 4, por lo que el bit inferior de las 'decenas' puede alternar el bit 1 de las 'unidades'. Usamos el resultado como un índice en nuestra tabla de residuos, imprimiendo ysolo si el resultado modular es cero.

Befunge -98, (41 bytes)

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

La simplicidad es asombrosa.

sed, 55

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

• La primera línea divide siglos exactos por 100.
• La segunda línea da 'N' a dígitos impares, 'y' a 4s y 'n' a no-4s.
• La tercera línea intercambia 'y' y 'n' si hay un penúltimo dígito impar (porque 10 es 2 mod 4)
• La línea final elimina todos los caracteres excepto el último.

Tenga en cuenta que los años no bisiestos pueden imprimirse según sean pares o impares no Ndependiendo de ellos. Considero que esta es una interpretación creativa de la regla que permite alternativas a 'sí' y 'no' sin especificar que tienen que ser consistentes.

Python2 - 37

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

Tenga en cuenta que si aes un entero no negativo, entonces a<1es una forma corta de escribir not bool(a). El último <1convierte efectivamente la expresión entre paréntesis en un booleano y niega el resultado.

La aplicación de la función ga un número entero nentre 1801 y 2400 devolverá Truesi nes un año bisiesto, y de lo Falsecontrario.

KDB (Q), 27 bytes

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

Explicación

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

Prueba

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

Esto crea una función sin nombre que acepta un argumento entero y devuelve un valor booleano. Para llamarlo, dale un nombre, por ejemplo f=y->....

Sin golf:

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

Ejemplo:

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);

Nada realmente especial, solo abusar del malabarismo de tipos.

C #, 23 bytes

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

Pruébalo en línea!

Fuente completa, incluidos los casos de prueba:

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;}

Caja de varitas

T-SQL 37 22 bytes

Guardado 15 bytes gracias al comentario de BradC.

La variable codificada habitual por falta de a stdin.

p.ej

DECLARE @ NVARCHAR(4) = '2016'

Entonces la solución es:

PRINT ISDATE(@+'0229')

Java 8, 49 45 22 20 bytes

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

-2 bytes gracias a @ OlivierGrégoire .

Pruébalo en línea.

Algunas soluciones de 22 bytes:

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

Pruébalo en línea.

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

Pruébalo en línea.

java.time.Year::isLeap

Pruébalo en línea.

Explicación:

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

Pruébalo en línea!

Javascript ES6, 32, 29, 26

Cualquiera de las siguientes líneas funciona:

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

Toma la entrada de stdin, con o sin espacios finales / nueva línea. Solo funciona en pequeñas máquinas endian (sí, como si todos estuvieran en BE en estos días). Salidas Y o N.

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

Explicación

Sin golf:

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

Primero, scanflee el año como un entero en y. Luego, y se modula con 4 o 400 dependiendo de si el año es divisible por 100. Si el resto es cero, el código ASCII para Y se asigna a y, de lo contrario, obtiene el código ASCII para N. El valor de y es ahora 0x000000??, donde 0x??está el personaje asignado. Al estar en una máquina little-endian, en la memoria esto se almacena como ?? 00 00 00. Esta es una cadena C terminada en NULL, que contiene solo los caracteres asignados. La dirección de y se pasa a put y se imprime el carácter (con una nueva línea final).

PowerShell, 31 bytes

¡Estoy emocionado de decir que jugué golf más corto que el incorporado!

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

Salidas verdaderas para años bisiestos y falsas de lo contrario.

Incorporado:

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

Sin embargo, si quisiera estirar la declaración "claramente le dice al usuario si es o no un año bisiesto" y hacer algo no estándar, podría guardar 3 bytes y usar:

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

Esto da como resultado 0los años bisiestos y 1 o superior para los años no bisiestos, lo que no me gusta, ya que preferiría devolver un valor de verdad más estándar para los años bisiestos.

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

Sin golf:

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 sin golf, porque LOLCODE es 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)