Цей виклик досить простий. Ви візьмете вхід, який становитиме рік з 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 

EDIT: Це засновано на стандартному григоріанському календарі: 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 ⊤(кодування) представляє його правий аргумент у базі, визначеній лівим аргументом. Я використовую базу 4 25 4в цьому розчині. Це представляє рік y як многочлен

y mod 400 = 100 a + 4 b + c,  де b <100 і c <4.

Нехай пропозиції α, β і γ представляють, якщо a, b і c ненульові: пропозиція γ помилкова, якщо y ділиться на 4, β ∧ γ помилкове, якщо y ділиться на 100, а α ∧ β ∧ γ - false, якщо y ділиться на 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 символів

Та сама ідея, але в перл.

$_=$_%($_%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

Шлях занадто простий. Спробуйте в Інтернеті: Демонстрація або Тест-джгут

редагувати: пропущено, що замість них можна надрукувати значення 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

Безголовки:

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, використовуючи ідею Девіда Хаммонда.

Стаклогічний, 226 байт (неконкурентоспроможний)

Так це правильно. Я склав програму в Stackylogic (non-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 - це найбільш заплутана мова, з якою я стикався, і надзвичайно нечитабельна: ви повинні знати, як виконана решта програми, перш ніж ви зможете прочитати поточний розділ, що редагується. Мені навіть довелося додати пробіли для читабельності під час її створення.

Мізерне пояснення

Це просте пояснення того, що він робить.

Стаклогілог не має жодних математичних функцій, тому це ускладнювало. Мені довелося більш жорстко кодувати, щоб перевірити, чи це конкретне число.

По-перше, ця програма зробить 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 (коли час процесора закінчився), якщо ні.

1936 Y 1805 N 1900 N 2272 Y 2400 Y

(коли виконується кілька разів)

CJam, 18 16 байт

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

Дає 1(truthy) за високосні роки та 0(falesy) в іншому випадку.

Тут запустіть усі тестові справи.

Пояснення

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.

Математика, 40 27 байт, 17 символів

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

Використовує 17 символів, але 27 байт. Дякуємо @alephalpha за пораду. Зауважте, що вертикальні бруски - це фактично U + 2223 для ділень. <U+F523>Слід замінити відповідний символ.

R, 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

C, 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 символи, оскільки це робить стандартне припущення, що аргументи негайно слідують за назвою програми, розділеними NULs. Крім того, передбачається, що єдиний аргумент кодується в 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";>;  ;#[

Простота є приголомшливою.

sed, 55

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

• Перший рядок розділяє точні століття на 100.
• Другий рядок дає "N" непарним цифрам, "y" - 4s, а "n" - не-4.
• Третій рядок міняється на "у" і "н", якщо є непарна передостанна цифра (бо 10 - це 2 моди 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інакше.

КДБ (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->....

Безголовки:

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

Хаскелл, 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 байт

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

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

Пояснення

Безголовки:

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

По-перше, scanfчитає рік як ціле число у. Тоді y модулюється з 4 або 400 залежно від того, чи рік ділиться на 100. Якщо решта дорівнює нулю, код ASCII для Y присвоюється y, інакше він отримує код ASCII для N. Значення y тепер 0x000000??, де 0x??призначений символ. Перебуваючи на машині з малою мірою, в пам'яті це зберігається як ?? 00 00 00. Це рядок C, що закінчується NULL, містить лише призначені символи. Адреса y передається в путівках, і знак друкується (із заднім рядком).

PowerShell, 31 байт

Я з радістю скажу, що я гольфував цей коротший за вбудований!

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

Виходи справжні для високосних років, а помилкові - інакше.

Вбудований:

[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

Безголовки:

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 невольф, тому що 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)