Эта задача довольно проста. Вы берете ввод, который будет годом с 1801 по 2400, и выводите, если это високосный год или нет.

Ваш ввод не будет содержать ни новой строки, ни пробелов:

1954

Вы будете выводить любым способом, который вам нравится, который четко говорит пользователю, является ли он високосным годом или нет (я приму y или n для да / нет)

Вы можете получить список високосных лет здесь: http://kalender-365.de/leap-years.php Я хотел бы отметить, что високосные годы не всегда четыре года. 1896 год високосный, а 1900 - нет. Годы, следующие за этим «пропуском»:

1900
2100
2200
2300

Тестовые случаи:

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

РЕДАКТИРОВАТЬ: Это основано на стандартном григорианском календаре: http://www.epochconverter.com/date-and-time/daynumbers-by-year.php

APL, 16 14 12 символов

Возвращает 0для високосного года, 1для не високосного года.

≥/⌽×4 25 4⊤⎕

Попробуйте это решение на tryapl.org . Обратите внимание, что я изменил решение на dfn, так {≥/⌽×4 25 4⊤⍵}как tryapl.com не поддерживает ⎕(принять пользовательский ввод). Обратите внимание, что ⎕это пустое поле, а не пропущенный символ.

То же решение в J:

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

объяснение

Dyadic ⊤(encode) представляет свой правый аргумент в базе, указанной его левым аргументом. Я использую базу 4 25 4в этом решении. Это представляет год у как полином

у мод 400 = 100 а + 4 b + c,  где b <100 и c <4.

Пусть предложения α, β и γ представляют собой, если a, b и c отличны от нуля: предложение γ неверно, если y делится на 4, β ∧ γ ложно, если у является делимым на 100 и & alpha ; ∧ & beta ; ∧ & gamma вне ложь, если у делится на 400.

Таблица истинности ( *представляющая «все равно») была бы предложением Δ, если y представляет собой високосный год:

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

Следующее утверждение выражает Δ в α , β и γ :

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

Из-за структуры этого утверждения можно выразить ¬Δ как сокращение, ≥/⌽α β γгде ≥ реализует ←. Это приводит к ответу, который я сейчас объясняю.

Pyth, 11 байт

!%|F_jQ*TT4

Эта полная программа читает из STDIN и печатает True для високосных лет и False противном случае.

Спасибо @Jakube за предложение Pyth и в основном перенос моего кода CJam.

Проверьте сами тестовые примеры в Pyth Compiler / Executor .

Как это работает

     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 байт

rS+2m<~e|4%!

Эта полная программа читает из STDIN и печатает 1 для високосных лет и 0 в противном случае.

Проверьте сами тестовые случаи в интерпретаторе CJam .

Как это работает

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 знак

Стандартным правилом yявляется високосный год, если 4 делится yи если 100 не делит yили 400 делит y. В коде

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

Нет необходимости в этих 100 и 400. Вместо этого достаточно проверить, делит ли 16 или 4 y, а 16 выбирается, если 25 делит y, 4 в противном случае. Гольф, это становится

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

Функция javascript, которая реализует это длиной 21 символ:

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

Perl, 28 26 символов

Та же идея, но в Perl.

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

Запустите, используя -lpпараметры. Например,

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

С тестом, установленным в качестве входа, это производит

1936
y
1805
n
1900
n
2272
y
2400
y

зернышко , 13 байт

Этот был более интересным, чем сначала показался. Потребовалось finagling, но я, наконец , смог заменить эти длинные ссылки 400с 4и hпеременной (= 100).

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

Выходы 1для високосного года, 0для не високосного года. Объяснение:

               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 байтов

xFm!%Q^d2[2TyT

Слишком просто. Попробуйте онлайн: демонстрация или тестовая привязь

edit: Пропущено, что вы можете печатать значения Truthy / Falsy вместо n/y. -4 байта

редактировать 2: Использовал идею квадратного корня Мартина. -1 байт

объяснение

                 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

Регекс, 83 62 38

Спасибо Тоби за советы по объединению обеих половин регулярного выражения.

Если мы сосредоточимся только на диапазоне 1801..2400 и предположим, что входные данные являются целыми числами:

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

Проверьте в Ruby ( ^= \Aи $= \Zпотому что Ruby) для желаемого диапазона:

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

(Бонус) за то, что должно работать не только на 1801..2400, но и на любой неотрицательный год:

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

Тест на Ruby ( ^= \Aи $= \Zпотому что Ruby) за первые 100000 лет:

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

Правило: (y%4==0) && (y%100!=0 || y%400==0)

Гольф: !(y%100<1&&y%400||y%4)(в основном по закону Де Моргана )

Функция, реализующая правило:

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

Тест (запустить в Firefox) просто чтобы быть уверенным:

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

Поскольку TI-BASIC является токенизированным, он часто конкурирует с простыми математическими задачами, но не с этим, поскольку нет «делимой» команды.Может быть, это все-таки, но это все же дольше, чем CJam и Pyth.

Это использует метод Дэвида Хаммонда.

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

Старый код в 16 байтов:

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(является «дробной частью»; Возведение в степень имеет более высокий приоритет, чем деление. В TI-BASIC закрытые скобки являются необязательными.

Я использую недокументированное поведение sub( команды, обычно используемое для получения подстроки: когда ее аргумент является числом, а не строкой, он делит число на 100. Он будет работать на калькуляторе серии TI-83 или 84.

20 -> 17 путем перестановки кода, чтобы разрешить удаление близких паренсов; 17 -> 16 путем замены 400 на 16; 16 -> 13, используя идею Дэвида Хаммонда.

Stackylogic, 226 байт (не конкурирует)

Да, именно так. Я сделал программу на Stackylogic (не-TC), которая была изобретена Хелкой Хомбой, для задачи, найденной здесь . Это сделано после вызова, поэтому не конкурирует.

Stackylogic имеет только двоичный вход, поэтому необходимо использовать 10 (или более, любые другие цифры будут игнорироваться) двоичный бит (сначала вводится младший значащий бит). Любые даты за пределами указанного диапазона могут потерпеть неудачу, так как он просто проверяет, что является введенным числом: он не покрывает ненужные даты

Это не только мой первый вызов со стайлогикой, но и первый вызов со стайлогикой вообще.

Будьте готовы к этому беспорядку:

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

Это заняло у меня так много времени, потому что Stackylogic - самый запутанный язык, с которым я когда-либо сталкивался, и чрезвычайно нечитаемый: вы должны знать, как выполнялась остальная часть программы, прежде чем читать текущий редактируемый раздел. Мне даже пришлось добавить пробелы для удобства чтения при его создании.

Скудное объяснение

Это простое объяснение того, что он делает.

Stackylogic не имеет никаких математических функций, так что это усложнило. Мне пришлось жестко кодировать большую часть этого, чтобы проверить, было ли это конкретное число.

Во-первых, эта программа выполнит NOR младших разрядов, отбрасывая их в процессе. это означает, что если он делится на 4, он перейдет к основной части программы, в противном случае выведите 0.

Во-вторых, указатель переносится в лабиринт стейлогии, отсюда, если следующие два бита равны нулю, он мгновенно выдаст 1 (как тогда он делится на 16, и, следовательно, високосный год, несмотря на любые другие условия), другое мудро, что он проверит, не является ли это любое из чисел, которые делятся на 4, но не високосный год, между 1801 и 2400.

Чтобы объяснить подробно, потребуется сделать этот пост во много раз дольше, чем это уже есть

Ассемблер IBM System Z - 56 байт.

(96 байтов источника. Ранее 712 384 202 байта источника, 168 байт исполняемого файла).

Меньшая версия все еще. Больше не сохраняет регистры вызывающего абонента, изменяет литеральное хранилище, изменяет режим адресации.

 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 

Новая версия. Это изменится с S0C1, если это високосный год, и зациклится, если это не так. Надеемся, что это соответствует требованию указания результата.

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  

Хорошо, так что не самое короткое (хотя это может быть, как только мы посмотрим на фактический исполняемый код плюс размер интерпретатора ...)

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  

Выход:

ABEND S0C1 для високосного года, S222 (когда время CPU истекло), если нет.

1936 Y 1805 N 1900 N 2272 Y 2400 Y

(при запуске несколько раз)

CJam, 18 16 байтов

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

Дает 1(правда) за високосные годы и 0(ложно) в противном случае.

Запустите все тесты здесь.

объяснение

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 байтов, 17 символов

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

Использует 17 символов, но 27 байтов. Спасибо @alephalpha за подсказку. Обратите внимание, что вертикальные полосы на самом деле U + 2223 для делений. <U+F523>Следует заменить соответствующий символ.

Р, 29

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

Тестовый забег

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

С, 81

Я могу сделать короче, но этот аккуратно придерживается типов 'char', без разбора аргумента (например, с atoi):

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

Он должен вызываться с именем длиной 4 символа, поскольку он предполагает стандартное предположение, что аргументы следуют сразу за именем программы, разделенные NUL. Кроме того, предполагается, что один аргумент закодирован в ASCII и не имеет начального пробела.

Объяснение:

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позиция цифры «десятки» в v[1]+2.

Если символы «десятки» и «единицы» добавляют к 96, мы заканчиваем 00, поэтому сделаем резервную копию двух символов, чтобы «десятки» и «единицы» указывали на номер столетия.

Теперь xor «единиц» с удвоенными «десятками», мод 4. Это работает, потому что 10==±2 mod 4, так что младший бит «десятков» может просто переключать бит 1 «единиц». Мы используем результат в качестве индекса в нашей таблице остатков, печатая yтолько в том случае, если модульный результат равен нулю.

Befunge -98, (41 байт)

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

Простота потрясающая.

Сед, 55

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

• Первая линия делит точные века на 100.
• Вторая строка дает «N» нечетным цифрам, «y» - 4, а «n» - не 4.
• Третья строка меняет местами 'y' и 'n', если есть нечетная предпоследняя цифра (потому что 10 - это 2 mod 4)
• Последняя строка удаляет все, кроме последнего символа

Обратите внимание, что не високосные годы могут быть напечатаны как nили в Nзависимости от того, являются ли они четными или нечетными. Я считаю это творческим толкованием правила, которое допускает альтернативы «да» и «нет», не указывая, что они должны быть последовательными.

Python2 - 37

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

Обратите внимание, что если aцелое неотрицательное число, то a<1это короткий способ записи not bool(a). Последний<1 таким образом, эффективно преобразует выражение в скобках в логическое значение и сводит на нет результат.

Применение функции gк целому числу nот 1801 до 2400 вернет, Trueесли nэто високосный год, и Falseиначе.

KDB (Q), 27 байтов

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

объяснение

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

Тест

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

Юлия, 30 28 байт

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

Это создает безымянную функцию, которая принимает целочисленный аргумент и возвращает логическое значение. Чтобы назвать его, дайте ему имя, напримерf=y->... .

Ungolfed:

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

Пример:

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

PHP - 45 байт

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

Ничего особенного, просто злоупотребление жонглированием шрифтами.

C #, 23 байта

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

Попробуйте онлайн!

Полный исходный код, включая контрольные примеры:

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 байт

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

Wandbox

T-SQL 37 22 байта

Сохранено 15 байт благодаря комментарию BradC.

Обычная жестко закодированная переменная из-за отсутствия stdin.

например

DECLARE @ NVARCHAR(4) = '2016'

Тогда решение:

PRINT ISDATE(@+'0229')

Java 8, 49 45 22 20 байт

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

-2 байта благодаря @ OlivierGrégoire .

Попробуйте онлайн.

Некоторые 22-байтовые решения:

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

Попробуйте онлайн.

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

Попробуйте онлайн.

java.time.Year::isLeap

Попробуйте онлайн.

Объяснение:

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 байтов

f i=gcd 80i>gcd 50i

Попробуйте онлайн!

Javascript ES6, 32, 29, 26

Работает любая из следующих строк:

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 байт

Принимает ввод из стандартного ввода, с или без завершающих пробелов / новой строки. Работает только на машинах с прямым порядком байтов (да, как все в настоящее время на BE). Выходы Y или N.

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

объяснение

Ungolfed:

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

Во-первых, scanfчитается год как целое число в y. Затем, y модулируется с 4 или 400 в зависимости от того, делится ли год на 100. Если остаток равен нулю, ASCII-код для Y присваивается y, в противном случае он получает ASCII-код для N. Значение y сейчас 0x000000??, где 0x??находится назначенный символ. Находясь на машине с прямым порядком байтов, в памяти это сохраняется как ?? 00 00 00. Это строка C с нулевым символом в конце, содержащая только назначенные символы. Адрес y передается в put, и печатается символ (с завершающим символом новой строки).

PowerShell, 31 байт

Я взволнован, чтобы сказать, что я играл в гольф ниже, чем встроенный!

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

Выводы true для високосных лет и false в противном случае.

Builtin:

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

Хотя, если бы я хотел расширить выражение «четко говорит пользователю, если это високосный год или нет» и сделать что-то нестандартное, я мог бы сэкономить 3 байта и использовать:

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

Это приводит 0к високосным годам и 1 или выше для не високосных лет, что мне не нравится, так как я предпочел бы возвращать более стандартное истинное значение для високосных лет.

LOLCODE, 228 202 159 байт

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

В Python ungolfed, потому что LOLCODE сбивает с толку:

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