To wyzwanie jest dość proste. Podejmiesz dane wejściowe, które będą rokiem od 1801 do 2400, i dane wyjściowe, jeśli będzie to rok przestępny, czy nie.

Twój wkład nie będzie zawierał znaków nowej linii ani spacji końcowych:

1954

Będziesz generować w dowolny sposób, który ci się podoba, który wyraźnie poinformuje użytkownika, czy jest to rok przestępny, czy nie (akceptuję y lub n dla tak / nie)

Listę lat przestępnych można uzyskać tutaj: http://kalender-365.de/leap-years.php Chciałbym zauważyć, że lata przestępne nie zawsze wynoszą cztery lata. 1896 to rok przestępny, ale 1900 nie. Lata następujące po tym „pominięciu” to:

1900
2100
2200
2300

Przypadki testowe:

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

EDYCJA: Opiera się na standardowym kalendarzu gregoriańskim: http://www.epochconverter.com/date-and-time/daynumbers-by-year.php

APL, 16 14 12 znaków

Zwraca 0za rok przestępny, 1za rok przestępny.

≥/⌽×4 25 4⊤⎕

Wypróbuj to rozwiązanie na tryapl.org . Zauważ, że zmieniłem rozwiązanie na {≥/⌽×4 25 4⊤⍵}dfn, ponieważ tryapl.com nie obsługuje ⎕(weź dane użytkownika). Pamiętaj, że ⎕jest to puste pole, a nie brakująca postać.

To samo rozwiązanie w J:

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

Wyjaśnienie

Dyadic ⊤(kodowanie) reprezentuje swój prawy argument w bazie określonej przez lewy argument. 4 25 4W tym rozwiązaniu używam bazy . To reprezentuje rok y jako wielomian

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

Niech zdania α, β i γ reprezentują, gdy a, b i c są niezerowe: Twierdzenie γ jest fałszywe, jeśli y można podzielić przez 4, β ∧ γ jest fałszywe, jeśli y jest podzielne przez 100, a α ∧ β ∧ γ wynosi false, jeśli y można podzielić przez 400.

Tabela prawdy ( *reprezentująca „nie przejmuj się”), w której twierdzenie represents reprezentuje, czy y jest rokiem przestępnym:

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

Poniższe wyrażenie wyraża w α , β i γ :

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

Ze względu na strukturę tego wyrażenia można wyrazić ¬Δ jako redukcję, ≥/⌽α β γgdzie ≥ implementuje ←. To prowadzi do odpowiedzi, którą teraz wyjaśniam.

Pyth, 11 bajtów

!%|F_jQ*TT4

Ten pełny program odczytuje ze STDIN i drukuje True przez lata przestępne, a False inaczej.

Dzięki @Jakube za sugerowanie Pytha i po prostu przeniesienie mojego kodu CJam.

Sprawdź samodzielnie przypadki testowe w Pyth Compiler / Executor .

Jak to działa

     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 bajtów

rS+2m<~e|4%!

Ten pełny program odczytuje ze STDIN i drukuje 1 dla lat przestępnych i 0 w przeciwnym razie.

Sprawdź samodzielnie przypadki testowe w interpretatorze CJam .

Jak to działa

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 znaków

Standardową zasadą jest to, że yrok przestępny następuje, jeśli 4 dzieli yi jeśli 100 nie dzieli ylub 400 dzieli y. W kodzie,

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

Nie ma potrzeby używania tych 100 i 400. Zamiast tego wystarczy sprawdzić, czy 16 lub 4 dzieli y, przy czym 16 wybiera się, jeśli 25 dzieli y, w przeciwnym razie 4. Gra w golfa

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

Zaimplementowana funkcja javascript ma długość 21 znaków:

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

Perl, 28 26 znaków

Ten sam pomysł, ale w perlu.

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

Uruchom używając -lpopcji. Na przykład,

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

Przy ustawionym teście jako danych wejściowych daje to wynik

1936
y
1805
n
1900
n
2272
y
2400
y

Pip , 13 bajtów

Ten był bardziej interesujący, niż się początkowo wydawało. Minęło trochę finagling, ale była w stanie zastąpić te długie odniesień do 400z 4oraz hzmienną (= 100).

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

Dane wyjściowe 1za rok przestępny, 0za rok przestępny. Wyjaśnienie:

               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 bajtów

xFm!%Q^d2[2TyT

O wiele za łatwe. Wypróbuj online: Demonstracja lub Uprząż testowa

edit: Nieodebrane, że możesz wydrukować wartości Prawdy / Falsy zamiast n/y. -4 bajty

edycja 2: Wykorzystano ideę pierwiastka kwadratowego Martina. -1 bajt

Wyjaśnienie

                 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

Podziękowania dla Toby za wskazówki dotyczące łączenia obu połówek wyrażenia regularnego.

Jeśli skupimy się tylko na zakresie 1801..2400 i założymy, że dane wejściowe są liczbami całkowitymi:

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

Testuj w Ruby ( ^= \Ai $= \Zponieważ Ruby) dla żądanego zakresu:

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

(Premia) za coś, co powinno działać nie tylko dla 1801..2400, ale dla każdego roku nieujemnego:

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

Testuj w Ruby ( ^= \Ai $= \Zponieważ Ruby) przez pierwsze 100000 lat:

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

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

Gra w golfa: !(y%100<1&&y%400||y%4)(głównie z wykorzystaniem prawa De Morgansa )

Funkcja implementująca regułę:

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

Test (uruchamiany w przeglądarce Firefox) dla pewności:

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

Ponieważ jest tokenizowany, TI-BASIC jest często konkurencyjny w prostych wyzwaniach matematycznych, ale nie w tym, ponieważ nie ma polecenia „podzielnego”. Może i tak jest, ale wciąż jest dłużej niż CJam i Pyth.

To wykorzystuje metodę Davida Hammonda.

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

Stary kod o wielkości 16 bajtów:

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

Nie golfowany:

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

fPart(jest „częścią ułamkową”; potęgowanie ma wyższy priorytet niż podział. W TI-BASIC przybliżenia są opcjonalne.

Używam nieudokumentowanego zachowania sub(polecenia, zwykle używanego do uzyskania podłańcucha: gdy jego argumentem jest liczba zamiast ciągu, dzieli liczbę przez 100. Będzie działać na kalkulatorze serii TI-83 lub 84.

20 -> 17 przez zmianę kolejności kodów, aby umożliwić usunięcie zbliżeń; 17 -> 16, zastępując 400 wartością 16; 16 -> 13, wykorzystując pomysł Davida Hammonda.

Stackylogic, 226 bajtów (niekonkurencyjny)

Tak to prawda. Stworzyłem program w Stackylogic (nie-TC), który został wymyślony przez Helkę Hombę, do wyzwania tutaj . Robi się to po wyzwaniu, więc nie konkuruje.

Stackylogic ma tylko dane binarne, więc 10 (lub więcej, więcej cyfr zostanie zignorowanych) należy zastosować bit binarny (najpierw najmniej znaczący bit). Wszelkie daty spoza określonego zakresu mogą się nie powieść, ponieważ po prostu sprawdza, jaka jest wprowadzona liczba: nie obejmuje niepotrzebnych dat

To nie tylko moje pierwsze wyzwanie w Stackylogic, ale w ogóle pierwsze wyzwanie w Stackylogic.

Przygotuj się na ten bałagan:

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

Zajęło mi to tak dużo czasu, ponieważ Stackylogic jest najbardziej zagmatwanym językiem, z jakim się spotkałem, i niezwykle nieczytelnym: musisz wiedzieć, jak zrobiła się reszta programu, zanim będziesz mógł przeczytać bieżącą edytowaną sekcję. Podczas tworzenia musiałem nawet dodać spacje dla czytelności.

Skromne wyjaśnienie

To proste wyjaśnienie tego, co robi.

Stackylogic nie ma żadnych funkcji matematycznych, dlatego było to trudniejsze. Musiałem zakodować większość z nich, aby sprawdzić, czy to konkretny numer.

Po pierwsze, program wykona NOR najmniej znaczących bitów, odrzucając je w procesie. oznacza to, że jeśli jest podzielna przez 4, przejdzie do głównej części programu, w przeciwnym razie wyjdzie 0.

Po drugie, wskaźnik jest przenoszony do labiryntu stackylogic, stąd, jeśli następne dwa bity są równe zero, natychmiast wyśle ​​1 (ponieważ wtedy jest podzielny przez 16, a więc rok przestępny pomimo innych warunków), inne mądre sprawdzi, czy nie jest to żadna z liczb, które można podzielić przez 4, ale nie jest to rok przestępny, między 1801 a 2400.

Aby wyjaśnić szczegółowo, wymagałoby to uczynienia tego postu wiele razy dłuższym niż jest już

Asembler IBM System Z - 56 bajtów.

(96 bajtów źródła. Wcześniej 712 384 202 bajtów źródła, 168-bajtowy plik wykonywalny).

Jeszcze mniejsza wersja. Nie zapisuje już rejestrów dzwoniącego, zmiany w dosłownej pamięci, zmieniony tryb adresowania.

 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 

Nowa wersja. Spowoduje to ABEND z S0C1, jeśli jest to rok przestępny, i zapętlenie, jeśli nie jest. Mam nadzieję, że spełnia to wymaganie wskazania wyniku.

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, więc nie najkrótszy (chociaż może to być raz, gdy spojrzymy na faktycznie wykonany kod plus rozmiar interpretera ...)

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  

Wynik:

ABEND S0C1 na rok przestępny, S222 (gdy skończy się czas procesora), jeśli nie.

1936 Y 1805 N 1900 N 2272 Y 2400 Y

(przy wielokrotnym uruchomieniu)

CJam, 18 16 bajtów

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

Daje 1(prawda) za lata przestępne i 0(fałsz) inaczej.

Tutaj uruchom wszystkie przypadki testowe.

Wyjaśnienie

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 bajtów, 17 znaków

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

Używa 17 znaków, ale 27 bajtów. Dzięki @alephalpha za wskazówkę. Zauważ, że pionowe kreski są w rzeczywistości U + 2223 dla podziałów. <U+F523>Należy zastąpić odpowiednim charakterze.

R, 29

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

Testowe uruchomienie

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

Mogę zrobić krócej, ale ten starannie przylega do typów „char”, bez analizowania argumentu (np. Za pomocą atoi):

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

Należy go wywołać nazwą o długości 4 znaków, ponieważ przyjmuje standardowe założenie, że argumenty następują bezpośrednio po nazwie programu, oddzielone wartościami NUL. Ponadto zakłada, że ​​pojedynczy argument jest zakodowany w ASCII i nie ma spacji wiodącej.

Wyjaśnienie:

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+9jest pozycją cyfry „dziesiątki” w v[1]+2.

Jeśli znaki „dziesiątki” i „jednostki” dodają do 96, to kończymy 00, więc wykonaj kopię zapasową dwóch znaków, aby „dziesiątki” i „jednostki” wskazywały na liczbę stulecia.

Teraz xor „jednostki” z dwukrotnością „dziesiątek”, mod 4. Działa to dlatego 10==±2 mod 4, że więc niższy bit „dziesiątek” może po prostu przełączać bit 1 z „jednostek”. Używamy wyniku jako indeksu w naszej tabeli resztek, drukując ytylko wtedy, gdy wynik modułowy wynosi zero.

Befunge -98, (41 bajtów)

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

Prostota jest niesamowita.

sed, 55

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

• Pierwsza linia dzieli dokładne stulecia przez 100.
• Drugi wiersz podaje „N” dla cyfr nieparzystych, „y” na 4s, a „n” na nie-4.
• Trzecia linia zamienia „y” i „n”, jeśli występuje nieparzysta przedostatnia cyfra (ponieważ 10 to 2 mod 4)
• Ostatnia linia usuwa wszystkie oprócz ostatniego znaku

Należy pamiętać, że lata bez przestępowania mogą być drukowane jako nlub w Nzależności od tego, czy są parzyste czy nieparzyste. Uważam to za twórczą interpretację reguły, która pozwala na alternatywy na „tak” i „nie” bez sprecyzowania, że ​​muszą być spójne.

Python2 - 37

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

Zauważ, że jeśli ajest nieujemną liczbą całkowitą, to a<1jest krótki sposób pisania not bool(a). Ten ostatni <1skutecznie konwertuje wyrażenie w nawiasach na wartość logiczną i neguje wynik.

Zastosowanie funkcji gdo liczby całkowitej nmiędzy 1801 a 2400 powróci, Truejeśli njest to rok przestępny, i w Falseinnym przypadku.

KDB (Q), 27 bajtów

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

Wyjaśnienie

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

Test

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

Julia, 30 28 bajtów

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

Tworzy to nienazwaną funkcję, która przyjmuje argument liczby całkowitej i zwraca wartość logiczną. Aby to nazwać, nadaj mu nazwę, np f=y->....

Nie golfowany:

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

Przykład:

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

PHP - 45 bajtów

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

Naprawdę nic specjalnego, tylko nadużywanie żonglowania czcionkami.

C #, 23 bajty

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

Wypróbuj online!

Pełne źródło, w tym przypadki testowe:

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 bajtów

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

Wandbox

T-SQL 37 22 bajtów

Zapisano 15 bajtów dzięki komentarzowi BradC.

Zwykła zmienna zakodowana z powodu braku a stdin.

na przykład

DECLARE @ NVARCHAR(4) = '2016'

Zatem rozwiązaniem jest:

PRINT ISDATE(@+'0229')

Java 8, 49 45 22 20 bajtów

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

-2 bajty dzięki @ OlivierGrégoire .

Wypróbuj online.

Niektóre 22 bajtowe rozwiązania:

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

Wypróbuj online.

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

Wypróbuj online.

java.time.Year::isLeap

Wypróbuj online.

Wyjaśnienie:

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 bajtów

f i=gcd 80i>gcd 50i

Wypróbuj online!

JavaScript ES6, 32, 29, 26

Działa dowolny z następujących wierszy:

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 bajtów

Pobiera dane wejściowe ze standardowego wejścia, z lub bez spacji / nowej linii. Działa tylko na małych komputerach Endian (tak, jak wszyscy są obecnie na BE). Wyjścia Y lub N.

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

Wyjaśnienie

Nie golfowany:

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

Po pierwsze, scanfczyta rok jako liczbę całkowitą y. Następnie y jest modulowane z 4 lub 400 w zależności od tego, czy rok jest podzielny przez 100. Jeśli reszta to zero, kod ASCII dla Y jest przypisywany do y, w przeciwnym razie otrzymuje kod ASCII dla N. Wartość y jest teraz 0x000000??, gdzie 0x??jest przypisany znak. Będąc na komputerze typu endian, w pamięci jest to przechowywane jako ?? 00 00 00. Jest to ciąg C zakończony znakiem NULL, zawierający tylko przypisane znaki. Adres y jest przekazywany do putów, a znak jest drukowany (z końcowym znakiem nowej linii).

PowerShell, 31 bajtów

Jestem podekscytowany, mówiąc, że grałem w tę grę krócej niż wbudowany!

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

Wyniki są prawdziwe dla lat przestępnych, a fałsz w przeciwnym razie.

Wbudowany:

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

Chociaż gdybym chciał rozciągnąć stwierdzenie „wyraźnie mówi użytkownikowi, czy to jest rok przestępny, czy nie” i zrobić coś niestandardowego, mógłbym zapisać 3 bajty i użyć:

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

Daje to wyniki 0dla lat przestępnych i 1 lub więcej dla lat przestępnych, co mi się nie podoba, ponieważ wolałbym zwrócić bardziej standardową wartość prawdy dla lat przestępnych.

Lolcode, 228 202 159 bajtów

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

Nie golfowany:

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

W Pythonie bez golfa, ponieważ LOLCODE jest mylący:

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