Este desafio é bastante simples. Você receberá uma entrada que será de um ano entre 1801 e 2400 e a saída, se for um ano bissexto ou não.

Sua entrada não terá novas linhas ou espaços finais:

1954

Você produzirá da maneira que desejar, que diga claramente ao usuário se é ou não um ano bissexto (aceitarei y ou n para sim / não)

Você pode obter uma lista dos anos bissextos aqui: http://kalender-365.de/leap-years.php Gostaria de observar que os anos bissextos nem sempre são quatro anos. 1896 é um ano bissexto, mas 1900 não é. Os anos seguintes a este "salto" são:

1900
2100
2200
2300

Casos de teste:

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

EDIT: Isso é baseado em um calendário gregoriano padrão: http://www.epochconverter.com/date-and-time/daynumbers-by-year.php

APL, 16 14 12 caracteres

Retorna 0para um ano bissexto, 1para um ano não bissexto.

≥/⌽×4 25 4⊤⎕

Experimente esta solução em tryapl.org . Observe que eu mudei a solução para o {≥/⌽×4 25 4⊤⍵}dfn porque o tryapl.com não suporta ⎕( aceite a entrada do usuário). Observe que ⎕é uma caixa vazia, não um caractere ausente.

A mesma solução em J:

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

Explicação

Diádico ⊤(codificação) representa seu argumento correto na base especificada por seu argumento esquerdo. Eu uso base 4 25 4nesta solução. Isso representa o ano y como um polinômio

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

Deixe proposições a, β, e y representam se , um b, e c são diferentes de zero: proposição γ é falso, se y é divisível por quatro, β ∧ γ é falso, se y é divisível por 100 e ct ∧ β ∧ γ seja false se y é dividível por 400.

Uma tabela de verdade ( *representando “não se importa”) onde a proposição Δ representa se y for um ano bissexto obtém:

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

A declaração a seguir expressa Δ em α , β e γ :

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

Devido à estrutura desta afirmação, pode-se expressar ΔΔ como a redução em ≥/⌽α β γque ≥ implementa ←. Isso leva à resposta que estou explicando agora.

Pitão, 11 bytes

!%|F_jQ*TT4

Este programa completo lê de STDIN e imprime True por anos bissextos e False de outra forma.

Obrigado a @Jakube por sugerir Pyth e basicamente portar meu código CJam.

Verifique você mesmo os casos de teste no Pyth Compiler / Executor .

Como 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 lê STDIN e imprime 1 por anos bissextos e 0 caso contrário.

Verifique você mesmo os casos de teste no interpretador CJam .

Como 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

A regra padrão é que yé um ano bissexto se 4 se divide ye se 100 não se divide you se 400 se dividem y. Em código,

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

Não há necessidade de 100 e 400. Em vez disso, basta verificar se 16 ou 4 divide y, com 16 escolhido se 25 divide y, 4 caso contrário. Golfed, isso se torna

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

Uma função javascript que implementa isso tem 21 caracteres:

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

Perl, 28 26 caracteres

Mesma ideia, mas em perl.

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

Execute usando as -lpopções. Por exemplo,

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

Com o teste definido como entrada, isso produz

1936
y
1805
n
1900
n
2272
y
2400
y

Pip , 13 bytes

Este foi mais interessante do que parecia à primeira vista. Demorou algum tempo para finalizar, mas finalmente consegui substituir aquelas referências longas com 400with 4e a hvariável (= 100).

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

Saídas 1para o ano bissexto, 0para o ano não bissexto. Explicação:

               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

Pitão, 19 15 14 bytes

xFm!%Q^d2[2TyT

Muito fácil. Experimente on-line: demonstração ou equipamento de teste

edit: Missed, que você pode imprimir valores Truthy / Falsy, em vez de n/y. -4 bytes

editar 2: Usou a idéia da raiz quadrada de Martin. -1 byte

Explicação

                 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

Agradecemos a Toby pelas dicas sobre como combinar as duas metades da regex.

Se focarmos apenas no intervalo 1801..2400 e assumirmos que a entrada é um número inteiro:

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

Teste em Ruby ( ^= \Ae $= \Zporque Ruby) para o intervalo desejado:

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

(Bônus) para algo que deve funcionar não apenas para 1801..2400, mas para qualquer ano não negativo:

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

Teste em Ruby ( ^= \Ae $= \Zporque Ruby) nos primeiros 100000 anos:

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

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

Golfe: !(y%100<1&&y%400||y%4)(principalmente usando a lei de De Morgans )

Uma função que implementa a regra:

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

Um teste (executado no Firefox) apenas para ter certeza:

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

Por ser tokenizado, o TI-BASIC geralmente é competitivo em desafios simples de matemática, mas não este, pois não existe um comando "divisível". Talvez seja afinal, mas ainda é mais longo que CJam e Pyth.

Isso usa o método de David Hammond.

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

Código antigo com 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(é "parte fracionária"; exponenciação tem maior precedência que divisão. No TI-BASIC, os close-parens são opcionais.

Uso o comportamento não documentado do sub(comando, geralmente usado para obter uma substring: quando seu argumento é um número em vez de uma string, ele divide o número por 100. Ele funcionará em uma calculadora da série TI-83 ou 84.

20 -> 17 reorganizando o código para permitir a remoção de parentes próximos; 17 -> 16 substituindo 400 por 16; 16 -> 13 usando a idéia de David Hammond.

Stackylogic, 226 bytes (não concorrente)

Sim isso está certo. Eu fiz um programa em Stackylogic (não-TC), que foi inventado por Helka Homba, para o desafio encontrado aqui . Isso é feito após o desafio, portanto não competitivo.

O Stackylogic possui apenas entrada binária, portanto, 10 (ou mais, mais dígitos serão ignorados) deve ser usado o binário de bits (o bit menos significativo inserido primeiro). Qualquer data fora do intervalo especificado pode falhar, pois simplesmente verifica qual é o número inserido: ele não cobre datas desnecessárias

Não é apenas este o meu primeiro desafio com stackylogic, mas o primeiro desafio com stackylogic.

Prepare-se para esta bagunça:

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

Isso demorou tanto para ser feito, porque o Stackylogic é a linguagem mais confusa que encontrei e extremamente ilegível: você precisa saber como o resto do programa foi executado antes de poder ler a seção atual que está sendo editada. Eu até tive que adicionar espaços para facilitar a leitura enquanto o criava.

Pouca explicação

Esta é uma explicação simples do que faz.

O Stackylogic não possui funções matemáticas, tornando isso mais difícil. Eu tive que codificar a maior parte, para verificar se era um número específico.

Primeiro, este programa fará uma NOR dos bits menos significativos, descartando-os no processo. isto significa que, se for divisível por 4, prosseguirá para a parte principal do programa, caso contrário, será gerado 0.

Segundo, o ponteiro é transportado para o labirinto da stackylogic, a partir daqui, se os próximos dois bits forem zero, ele produzirá instantaneamente 1 (então é divisível por 16 e, portanto, um ano bissexto apesar de quaisquer outras condições), outras sábio, ele verificará se nenhum dos números é divisível por 4, mas não um ano bissexto, entre 1801 e 2400.

Para explicar em detalhes, envolveria tornar este post muito mais longo do que já é

Montador do IBM System Z - 56 bytes.

(96 bytes de origem. Anteriormente 712 384 202 bytes de origem, executável de 168 bytes).

Versão menor ainda. Não salva mais os registros de chamadas, alterações no armazenamento literal, modo de endereçamento alterado.

 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 

Nova versão. Isso será ABEND com um S0C1 se for um ano bissexto, e repetido se não for. Espero que isso cumpra o requisito de indicar o 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, então não é o mais curto (embora possa ser uma vez que analisemos o código executado real mais o tamanho do interpretador ...)

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  

Saída:

ABEND S0C1 por um ano bissexto, S222 (quando o tempo da CPU acabar), se não.

1936 Y 1805 N 1900 N 2272 Y 2400 Y

(quando executado várias vezes)

CJam, 18 16 bytes

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

Dá 1(de verdade) por anos bissextos e 0(falsamente) de outra forma.

Execute todos os casos de teste aqui.

Explicação

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)

Usa 17 caracteres, mas 27 bytes. Obrigado a @alephalpha pela dica. Observe que as barras verticais são na verdade U + 2223 para divisões. O <U+F523>deve ser substituído pelo caractere correspondente.

R, 29

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

Execução de teste

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

Eu posso fazer mais curto, mas este adere perfeitamente aos tipos 'char', sem analisar o argumento (por exemplo, com atoi):

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

Ele deve ser chamado com um nome de 4 caracteres, porque assume a premissa padrão de que os argumentos seguem imediatamente o nome do programa, separados por NULs. Além disso, assume que o argumento único é codificado em ASCII e não possui espaço à esquerda.

Explicação:

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é a posição do dígito 'dezenas' em v[1]+2.

Se os caracteres 'dezenas' e 'unidades' forem adicionados a 96, terminamos com 00, portanto, faça backup de dois caracteres, para que 'dezenas' e 'unidades' aponte para o número do século.

Agora xor 'units' com o dobro das 'dezenas', mod 4. Isso funciona porque 10==±2 mod 4, portanto, o bit inferior das 'dezenas' pode alternar apenas o bit 1 das 'unidades'. Usamos o resultado como um índice em nossa tabela de remanescentes, imprimindo yapenas se o resultado modular for zero.

Befunge -98, (41 bytes)

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

Simplicidade é incrível.

sed, 55

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

• A primeira linha divide séculos precisos por 100.
• A segunda linha fornece 'N' para dígitos ímpares, 'y' para 4s e 'n' para não-4s.
• A terceira linha troca 'y' e 'n' se houver um dígito penúltimo ímpar (porque 10 é 2 mod 4)
• A linha final exclui tudo, exceto o último caractere

Observe que anos não bissextos podem ser impressos como nou Ndependendo de serem pares ou ímpares. Considero isso uma interpretação criativa da regra que permite alternativas ao 'sim' e 'não' sem especificar que elas devem ser consistentes.

Python2 - 37

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

Observe que se aé um número inteiro não negativo, a<1é uma maneira curta de escrever not bool(a). O último <1converte efetivamente a expressão entre parênteses em um booleano e nega o resultado.

A aplicação da função ga um número inteiro nentre 1801 e 2400 retornará Truese nfor um ano bissexto ou Falsenão.

KDB (Q), 27 bytes

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

Explicação

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

Teste

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

Isso cria uma função sem nome que aceita um argumento inteiro e retorna um valor booleano. Para chamá-lo, dê um nome, por exemplo f=y->....

Ungolfed:

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

Exemplo:

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, apenas abusando do malabarismo de tipos.

C #, 23 bytes

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

Experimente online!

Fonte completa, incluindo casos de teste:

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

Economizou 15 bytes graças ao comentário de BradC.

A variável codificada habitual por falta de a stdin.

por exemplo

DECLARE @ NVARCHAR(4) = '2016'

Então a solução é:

PRINT ISDATE(@+'0229')

Java 8, 49 45 22 20 bytes

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

-2 bytes graças a @ OlivierGrégoire .

Experimente online.

Algumas soluções de 22 bytes:

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

Experimente online.

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

Experimente online.

java.time.Year::isLeap

Experimente online.

Explicação:

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

Experimente online!

Javascript ES6, 32, 29, 26

Qualquer uma das seguintes linhas 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

Retorna a entrada do stdin, com ou sem espaços à direita / nova linha. Só funciona em pequenas máquinas endian (sim, como todo mundo está no BE atualmente). Saídas Y ou N.

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

Explicação

Ungolfed:

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

Primeiro, scanflê o ano como um número inteiro em y. Então, y é modulado com 4 ou 400, dependendo se o ano é divisível por 100. Se o restante for zero, o código ASCII para Y é atribuído a y, caso contrário, ele obtém o código ASCII para N. O valor de y é agora 0x000000??, onde 0x??está o caractere atribuído. Por estar em uma máquina little-endian, na memória isso é armazenado como ?? 00 00 00. Esta é uma cadeia C terminada em NULL, contendo apenas os caracteres atribuídos. O endereço de y é passado para put e o caractere é impresso (com uma nova linha à direita).

PowerShell, 31 bytes

Estou animado para dizer que joguei este mais curto do que o embutido!

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

Resultados verdadeiros para os anos bissextos e falsos caso contrário.

Construídas em:

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

No entanto, se eu quisesse esticar a declaração 'informa claramente ao usuário se é ou não um ano bissexto' e fazer algo fora do padrão, eu poderia salvar 3 bytes e usar:

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

Isso produz 0anos bissextos e 1 ou superior para anos não bissextos, o que eu não gosto, pois prefiro retornar um valor mais padrão de verdade para os anos bissextos.

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

Em Python não-destruído, porque 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)