Czy to rok przestępny?

41

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

Kevin Cruijssen
źródło
9
Powinieneś być bardziej precyzyjny: dany rok jest rokiem przestępnym, jeśli tylko i wyłącznie wtedy, gdy jest (divisible by 4)∧((divisible by 100)→(divisible by 400)).
LegionMammal978
Twój wkład nie będzie zawierał znaków nowej linii ani spacji końcowych. Cholera, zaoszczędziłoby mi to 2 bajty ...
Dennis
2
Powinieneś rozszerzyć akceptowany zakres wejściowy do AD 1601 do 2400. Obejmuje to dwa 400-letnie cykle gregoriańskie (które proleptycznie rozpoczynają się w poniedziałek).
David R Tribble
2
Czy fałsz, jeśli rok przestępny i prawda, jeśli nie rok przestępny, liczą się jako „wyraźnie informuje użytkownika, czy jest, czy nie”?
lirtosiast
@lirtosiast Myślę, że tak. Zakłada to wielu użytkowników.
aloisdg mówi Przywróć Monikę

Odpowiedzi:

22

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.

FUZxxl
źródło
16

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.
Dennis
źródło
15

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.
Dennis
źródło
Mam jeszcze kilka alternatywnych 12 bajtów. Może znajdziesz w nich coś, co obniży to do 11? r2/~~\e|i4%!, r2/~~\~e|4%!, r2/:~~\e|4%!, r2/S*~\e|4%!I 13 bajtówr2/:~W%:e|4%!
Martin Ender
@ MartinBüttner: Są też r2/:i:\e|4%!(12) i r2/:i(fe|~4%!(13). Próbowałem nawet GolfScript (który nie wymaga r), ale or4jest interpretowany jako pojedynczy token. Gdyby tylko dane wejściowe miały końcowy znak nowej linii ...
Dennis
14

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
David Hammen
źródło
Użyłem twojej sugestii w mojej odpowiedzi, nie widziałem twojej. Teraz wycofałem się. Uwaga: powinieneś podać EcmaScript 6, w przeciwnym razie ktoś będzie narzekał, że „nie działa w Chrome”
edc65
@ edc65: Cóż, powinien określić EcmaScript 6, ponieważ jest to EcmaScript 6. Notacja funkcji strzałki ( y=>...) jest funkcją ES6.
Tim Čas,
Czy nie powinny to być dwie odpowiedzi?
dfeuer
9

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
DLosc
źródło
9

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
Jakube
źródło
9

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
rr
źródło
1
Jeśli tak (?!), możesz połączyć dwie połówki: (?!00)([02468][048]|[13579][26])(00)?$- za 38. Nie będzie to jednak działać przez lata z cyframi.
Toby Speight
9

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>

edc65
źródło
3
Możesz to zmniejszyć o sześć znaków, jeśli używasz !(y%(y%25?4:16))zamiast !(y%100<1&&y%400||y%4). Dla tych, którym przeszkadza trójkowy operator, możesz użyć !(y%(4<<2*!(y%25)))i nadal zapisać trzy znaki !(y%100<1&&y%400||y%4).
David Hammen
1
Sugestia Davida Hammana jest identyczna z jego odpowiedzią, więc myślę, że powinieneś zachować długość 27.
lirtosiast
9

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.

lirtosiast
źródło
9

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ż

Zniszczalna cytryna
źródło
8

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)

Steve Ives
źródło
Zmniejszenie do 376 bajtów poprzez utworzenie minimalnego rozmiaru obszarów pamięci (13 bajtów), usunięcie obszaru przejściowego „leapflag” i włączenie do programu tylko jednego roku (zamiast 5).
Steve Ives
384 bajty przez dostarczenie lekko sformatowanego wyjścia:
Steve Ives
1
+1 za interesujący i edukacyjny wybór języka. :-)
Toby Speight
Mógłbym zaoszczędzić kilka bajtów, porzucając konwencję i nie zawracając sobie głowy zapisaniem rejestrów dzwoniących na początku, ponieważ program nigdy nie wraca do dzwoniącego. To bardzo zła forma.
Steve Ives
7

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.
Martin Ender
źródło
6

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.

LegionMammal978
źródło
2
Jest to jedna z tych zagadek, gdzie Mathematica oferuje rozwiązanie, które czuje rodzaju cheaty: LeapYearQ [#] i
zeldredge
1
Możesz użyć do reprezentowania Divisible:, #∣4&&(!#∣100||#∣400)&21 znaków, 27 bajtów UTF-8.
alephalpha
@zeldredge Nadal nie jest to krótsze niż rozwiązanie APL.
FUZxxl
@alephalpha Alternatywnie, możesz użyć U+F523( \[Implies]), aby uzyskać #∣4&&(#∣100<U+F523>#∣400)&19 znaków (ale nadal 27 bajtów).
LegionMammal978
Jest to standardowa luka; używasz funkcji, która wykonuje dokładnie wymaganą funkcjonalność. To jest verboten.
FUZxxl
6

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
MickyT
źródło
5

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.

Toby Speight
źródło
4

Befunge -98, (41 bajtów)

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

Prostota jest niesamowita.

MegaTom
źródło
4

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.

Toby Speight
źródło
4

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.

Mathmandan
źródło
3

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
WooiKent Lee
źródło
3

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
Alex A.
źródło
3

PHP - 45 bajtów

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

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

Most Północny
źródło
3

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
        }
    }
}
adrianmp
źródło
3

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')
S.Karras
źródło
1
Jeśli dobrze czytam wyzwanie, myślę, że możesz zaoszczędzić 10PRINT ISDATE(@+'0229')
sporo
3

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
Kevin Cruijssen
źródło
Kolejne 22 bajtów alternatywa: java.time.Year::isLeap.
Olivier Grégoire,
2
I rozwiązanie 20 bajtów:n->n%(n%25<1?16:4)<1
Olivier Grégoire,
@ OlivierGrégoire Nice 20-byter! I nie zdawałem sobie sprawy, że wbudowane było również 22 bajty. :)
Kevin Cruijssen
2

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)
Qwertiy
źródło
2

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

Andrea Biondo
źródło
1
„Będziesz generować w dowolny sposób, który ci się podoba, co wyraźnie powie użytkownikowi, czy jest to rok przestępny, czy nie”. Czy możesz zapisać kilka bajtów, zwracając 1 lub 0 zamiast „Y” lub „N”? (Tak naprawdę nie znam C, tylko zgaduję.)
Alex A.
@AlexA. Dzięki za edycję - teraz wiem, jak wyróżnić składnię :) Rozważyłem to. Kody ASCII są dwiema cyframi, więc nie zyskujesz na tym (nawiasem mówiąc, używam wielkich liter Y i N, aby zapisać 2 bajty, ponieważ małe litery mają 3 cyfry). Są sekwencyjne, więc może się przydać. Niestety, z powodu pierwszeństwa operatora, mam taką samą liczbę bajtów: main(y){scanf("%d",&y);y=!(y%(y%100?4:400))+48;puts(&y);}. Mogę zejść do 48 bajtów, jeśli mogę wypisać pustą linię dla lat przestępnych i dowolnego znaku (ASCII 1-99) w przeciwnym razie, ale wydaje mi się, że to trochę nagina reguły. Co myślisz?
Andrea Biondo
Musiałem zrobić coś złego, licząc znaki. Jest 57, nie 59 :)
Andrea Biondo
1
Tak, powiedziałbym, że to naginanie zasad, ale możesz skomentować pytanie i poprosić PO o potwierdzenie. Dobrym narzędziem do zliczania bajtów jest to - myślę, że wielu ludzi tutaj z niego korzysta.
Alex A.
Nie, zostawię to tak, jak jest :)
Andrea Biondo
2

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.

ThePoShWolf
źródło
2

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)
OldBunny2800
źródło
Czy zdefiniowanie funkcji byłoby krótsze?
Leaky Nun
prawdopodobnie, ale będę go później edytować.
OldBunny2800
Zaktualizowałeś kod główny, aby był funkcją, ale nie kod nieoznaczony?
Destructible Lemon
Myślałem, że LOLCODE ma automatyczny przymus typu, co oznacza, że ​​każda niezerowa wartość jest równoważna WIN..
Leaky Nun
Tak, ale jak mogę tego użyć? Nie sądzę, że robię casting.
OldBunny2800