Ist es ein Schaltjahr?

41

Diese Herausforderung ist ganz einfach. Sie nehmen eine Eingabe, die ein Jahr von 1801 bis 2400 ist, und geben aus, ob es ein Schaltjahr ist oder nicht.

Ihre Eingabe wird keine Zeilenumbrüche oder Leerzeichen enthalten:

1954

Sie geben auf jede Art und Weise aus, die Ihnen gefällt, und teilen dem Benutzer klar mit, ob es sich um ein Schaltjahr handelt oder nicht (ich akzeptiere y oder n für yes / no).

Eine Liste der Schaltjahre finden Sie hier: http://kalender-365.de/leap-years.php Ich möchte darauf hinweisen, dass Schaltjahre nicht immer vier Jahre sind. 1896 ist ein Schaltjahr, 1900 nicht. Die Jahre, die diesem "Überspringen" folgen, sind:

1900
2100
2200
2300

Testfälle:

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

BEARBEITEN: Dies basiert auf einem gregorianischen Standardkalender: http://www.epochconverter.com/date-and-time/daynumbers-by-year.php

Kevin Cruijssen
quelle
9
Sie sollten klarer sein: Ein gegebenes Jahr ist genau dann ein Schaltjahr, wenn es ist (divisible by 4)∧((divisible by 100)→(divisible by 400)).
LegionMammal978
Ihre Eingabe enthält keine Zeilenumbrüche oder Leerzeichen. Verdammt, das hätte mir 2 Bytes erspart ...
Dennis
2
Sie sollten den akzeptierten Eingabebereich auf AD 1601 bis 2400 erweitern. Dies deckt zwei 400-jährige Gregorianische Zyklen ab (die voraussichtlich am Montag beginnen).
David R Tribble
2
Zählt falsisch, wenn Schaltjahr und wahrheitsgemäß, wenn nicht ein Schaltjahr als "dem Benutzer klar sagt, ob es ist oder nicht"?
Lirtosiast
@lirtosiast Ich denke schon. Viele Benutzer gehen davon aus.
Aloisdg sagt Reinstate Monica

Antworten:

22

APL, 16 14 12 Zeichen

Gibt 0für ein Schaltjahr zurück, 1für ein Nicht-Schaltjahr.

≥/⌽×4 25 4⊤⎕

Probieren Sie diese Lösung auf tryapl.org aus . Beachten Sie, dass ich die Lösung auf dfn geändert habe, {≥/⌽×4 25 4⊤⍵}da tryapl.com dies nicht unterstützt (Benutzereingaben übernehmen). Beachten Sie, dass es sich um ein leeres Feld handelt und kein fehlendes Zeichen.

Die gleiche Lösung in J:

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

Erläuterung

Dyadic (encode) repräsentiert sein rechtes Argument in der Basis, die durch sein linkes Argument angegeben wird. Ich benutze Basis 4 25 4in dieser Lösung. Dies repräsentiert das Jahr y als Polynom

y mod 400 = 100 a + 4 b + c  wobei b <100 und c <4.

Lassen Sie die Sätze α, β und γ darstellen, wenn a, b und c nicht Null sind: Satz γ ist falsch, wenn y durch 4 teilbar ist , βγ ist falsch, wenn y durch 100 teilbar ist und αβγ ist false, wenn y durch 400 teilbar ist.

Eine Wahrheitstabelle ( *die "egal" darstellt), in der Satz & Dgr; darstellt, wenn y ein Schaltjahr ist, ergibt sich:

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

Die folgende Aussage drückt Δ in α , β und γ aus :

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

Aufgrund der Struktur dieser Aussage kann man ¬Δ als die Reduktion ausdrücken, ≥/⌽α β γbei der ≥ ← implementiert. Dies führt zu der Antwort, die ich gerade erkläre.

FUZxxl
quelle
16

Pyth, 11 Bytes

!%|F_jQ*TT4

Dieses vollständige Programm liest STDIN aus und gibt True für Schaltjahre und False für andere aus.

Vielen Dank an @Jakube, der Pyth vorgeschlagen und im Grunde meinen CJam-Code portiert hat.

Überprüfen Sie die Testfälle selbst im Pyth Compiler / Executor .

Wie es funktioniert

     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
quelle
15

CJam, 12 Bytes

rS+2m<~e|4%!

Dieses vollständige Programm liest aus STDIN und gibt 1 für Schaltjahre und 0 für andere aus.

Überprüfen Sie die Testfälle selbst im CJam-Interpreter .

Wie es funktioniert

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
quelle
Ich habe noch ein paar 12-Byte-Alternativen. Vielleicht kannst du etwas in ihnen finden, um es auf 11 zu bringen? r2/~~\e|i4%!, r2/~~\~e|4%!, r2/:~~\e|4%!, r2/S*~\e|4%!Und der 13 - Byter2/:~W%:e|4%!
Martin Ender
@ MartinBüttner: Es gibt auch r2/:i:\e|4%!(12) und r2/:i(fe|~4%!(13). Ich habe sogar GolfScript ausprobiert (was nicht erforderlich ist r), es or4wird jedoch als einzelnes Token interpretiert. Wenn nur die Eingabe eine nachgestellte Zeile hätte ...
Dennis
14

Javascript (ES6), 21 Zeichen

Die Standardregel ist, dass yein Schaltjahr ist, wenn 4 dividiert yund entweder 100 nicht dividiert yoder 400 dividiert y. In Code,

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

100 und 400 sind nicht erforderlich. Stattdessen reicht es aus, zu überprüfen, ob 16 oder 4 y dividieren, wobei 16 ausgewählt wird, wenn 25 y dividiert, andernfalls 4. Golfen wird das

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

Eine Javascript-Funktion, die dies implementiert, ist 21 Zeichen lang:

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


Perl, 28 26 Zeichen

Gleiche Idee, aber in Perl.

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

Führen Sie mit den -lpOptionen. Zum Beispiel,

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

Wenn der Test als Eingabe festgelegt ist, wird dies erzeugt

1936
y
1805
n
1900
n
2272
y
2400
y
David Hammen
quelle
Ich hatte Ihren Vorschlag in meiner Antwort verwendet und Ihren nicht gesehen. Jetzt habe ich zurückgerollt. Hinweis: Sie sollten EcmaScript 6 angeben, da sich sonst jemand beschwert, dass es in Chrome nicht funktioniert
edc65
@ edc65: Nun, er sollte EcmaScript 6 angeben, da es sich um EcmaScript 6 handelt. Die Pfeilfunktionsnotation ( y=>...) ist eine ES6-Funktion.
Tim Čas
Sollte das nicht zwei Antworten sein?
1.
9

Pip , 13 Bytes

Dieser war interessanter als es auf den ersten Blick erschien. Es dauerte ein bisschen, aber ich konnte endlich die langen Verweise auf 400mit 4und die hVariable (= 100) ersetzen .

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

Ausgaben 1für Schaltjahr, 0für Nichtschaltjahr. Erläuterung:

               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
quelle
9

Pyth, 19 15 14 Bytes

xFm!%Q^d2[2TyT

Viel zu einfach. Probieren Sie es online aus: Vorführ- oder Testgeschirr

edit: Verpasst, dass du Truthy / Falsy-Werte statt drucken kannst n/y. -4 Byte

edit 2: Verwendete die Quadratwurzelidee von Martin. -1 Byte

Erläuterung

                 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
quelle
9

Regex, 83 62 38

Vielen Dank an Toby für die Tipps zum Kombinieren der beiden Hälften des Regex.

Wenn wir uns nur auf den Bereich 1801..2400 konzentrieren und davon ausgehen, dass es sich bei der Eingabe um Ganzzahlen handelt:

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

Test in Ruby ( ^= \Aund $= \Zweil Ruby) für den gewünschten Bereich:

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

(Bonus) für etwas, das nicht nur für 1801..2400 funktionieren sollte, sondern für jedes nicht negative Jahr:

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

Test in Ruby ( ^= \Aund $= \Zweil Ruby) für die ersten 100000 Jahre:

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-
quelle
1
Wenn Sie haben (?!), können Sie die beiden Hälften kombinieren: (?!00)([02468][048]|[13579][26])(00)?$- für 38. Das funktioniert jedoch nicht für einstellige Jahre.
Toby Speight
9

JavaScript ( ES6 ) 27

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

Golfen: !(y%100<1&&y%400||y%4)(hauptsächlich nach dem Gesetz von De Morgans )

Eine Funktion, die die Regel implementiert:

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

Ein Test (in Firefox ausgeführt), um sicherzugehen:

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
quelle
3
Sie können dies um sechs Zeichen reduzieren, wenn Sie !(y%(y%25?4:16))anstelle von verwenden !(y%100<1&&y%400||y%4). Für diejenigen, die vom ternären Operator gestört werden, können Sie !(y%(4<<2*!(y%25)))drei Zeichen verwenden und trotzdem speichern !(y%100<1&&y%400||y%4).
David Hammen
1
Der Vorschlag von David Hammen ist identisch mit seiner Antwort. Ich denke, Sie sollten den
Wert
9

TI-BASIC, 20 17 16 13

Da TI-BASIC tokenisiert ist, ist es bei einfachen mathematischen Herausforderungen oft wettbewerbsfähig, aber nicht bei diesem, da es keinen "teilbaren" Befehl gibt. Vielleicht ist es doch so, aber das ist immer noch länger als CJam und Pyth.

Dies erfolgt nach der Methode von David Hammond.

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

Alter Code bei 16 Bytes:

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

Ungolfed:

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

fPart(ist "Bruchteil"; Potenzierung hat Vorrang vor Division. In TI-BASIC sind enge Parens optional.

Ich verwende das undokumentierte Verhalten des sub(Befehls, das normalerweise zum Abrufen einer Teilzeichenfolge verwendet wird: Wenn das Argument eine Zahl anstelle einer Zeichenfolge ist, dividiert es die Zahl durch 100. Es funktioniert mit einem Taschenrechner der Serie TI-83 oder 84.

20 -> 17 durch Neuanordnen des Codes, um das Entfernen von eng beieinander liegenden Elementen zu ermöglichen; 17 -> 16 durch Ersetzen von 400 durch 16; 16 -> 13 nach der Idee von David Hammond.

Lirtosiast
quelle
9

Stackylogic, 226 Bytes (nicht konkurrierend)

Ja, das ist richtig. Ich habe ein Programm in Stackylogic (Nicht-TC) erstellt, das von Helka Homba für die hier zu findende Herausforderung erfunden wurde . Dies erfolgt nach der Herausforderung, also ohne Konkurrenz.

Stackylogic hat nur eine Binäreingabe, daher müssen 10 (oder mehr, alle Ziffern werden ignoriert) Bit-Binär verwendet werden (niedrigstwertiges Bit wird zuerst eingegeben). Alle Daten außerhalb des angegebenen Bereichs können fehlschlagen, da lediglich überprüft wird, wie die eingegebene Zahl lautet: Es werden keine unnötigen Daten erfasst

Dies ist nicht nur meine erste Herausforderung mit Stackylogic, sondern überhaupt die erste Herausforderung mit Stackylogic.

Mach dich bereit für dieses Chaos:

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

Das hat so lange gedauert, weil Stackylogic die verwirrendste Sprache ist, die mir begegnet ist, und extrem unleserlich: Sie müssen wissen, wie der Rest des Programms ausgeführt wurde, bevor Sie den aktuellen Abschnitt lesen können, der gerade bearbeitet wird. Ich musste sogar Leerzeichen für die Lesbarkeit beim Erstellen hinzufügen.

Magere Erklärung

Dies ist eine einfache Erklärung dessen, was es tut.

Stackylogic hat keine mathematischen Funktionen, was dies erschwert. Ich musste das meiste fest codieren, um zu überprüfen, ob es sich um eine bestimmte Nummer handelte.

Erstens führt dieses Programm ein NOR der niedrigstwertigen Bits durch und verwirft sie dabei. Dies bedeutet, dass, wenn es durch 4 teilbar ist, zum Hauptteil des Programms übergegangen wird, andernfalls wird 0 ausgegeben.

Zweitens wird der Zeiger auf das Labyrinth der Stackylogic übertragen. Wenn die nächsten beiden Bits Null sind, wird sofort 1 ausgegeben (da es dann durch 16 teilbar ist und somit trotz aller anderen Bedingungen ein Schaltjahr) In diesem Fall wird geprüft, ob es sich nicht um eine durch 4 teilbare Zahl handelt, sondern um ein Schaltjahr zwischen 1801 und 2400.

Im Detail zu erklären, würde bedeuten, diesen Beitrag um ein Vielfaches länger zu machen als er bereits ist

Zerstörbare Zitrone
quelle
8

IBM System Z-Assembler - 56 Byte.

(96 Byte der Quelle. Vorher 712 384 202 Byte der Quelle, 168 Byte ausführbar).

Kleinere Version noch. Speichert keine Anruferregister mehr, ändert den Literalspeicher und den Adressierungsmodus.

 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 

Neue Version. Dies wird mit einem S0C1 ABENDEN, wenn es ein Schaltjahr ist, und eine Schleife, wenn es nicht ist. Hoffentlich erfüllt dies die Anforderung, das Ergebnis anzugeben.

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, also nicht die kürzeste (obwohl es sein kann, dass wir uns einmal den tatsächlich ausgeführten Code und die Interpretergröße ansehen ...)

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  

Ausgabe:

BEENDEN SIE S0C1 für ein Schaltjahr, S222 (wenn die CPU-Zeit abgelaufen ist), wenn nicht.

1936 Y 1805 N 1900 N 2272 Y 2400 Y

(wenn mehrmals ausgeführt)

Steve Ives
quelle
Bis zu 376 Byte, indem Speicherbereiche auf eine Mindestgröße (13 Byte) festgelegt werden, der Staging-Bereich "leapflag" entfernt wird und nur ein einziges Jahr (anstatt 5) im Programm enthalten ist.
Steve Ives
384 Bytes durch Bereitstellung einer leicht formatierten Ausgabe:
Steve Ives
1
+1 für interessante und lehrreiche Sprachwahl. :-)
Toby Speight
Ich könnte ein paar Bytes einsparen, wenn ich die Konvention aufgeben und mich nicht darum kümmern würde, die Anruferregister zu Beginn zu speichern, da das Programm niemals zum Aufrufer zurückkehrt. Das ist eine sehr schlechte Form.
Steve Ives
7

CJam, 18 16 Bytes

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

Gibt 1(wahr) für Schaltjahre und 0(falsch) sonst.

Führen Sie hier alle Testfälle aus.

Erläuterung

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
quelle
6

Mathematica, 40 27 Bytes, 17 Zeichen

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

Verwendet 17 Zeichen, aber 27 Bytes. Danke an @alephalpha für den Tipp. Beachten Sie, dass die vertikalen Balken für Teilungen tatsächlich U + 2223 sind. Das <U+F523>sollte durch das entsprechende Zeichen ersetzt werden.

LegionMammal978
quelle
2
Dies ist eines dieser Rätsel, bei denen Mathematica eine Lösung anbietet, die sich betrügerisch anfühlt: LeapYearQ [#] &
zeldredge
1
Sie können Folgendes darstellen Divisible:, #∣4&&(!#∣100||#∣400)&21 Zeichen, 27 UTF-8-Bytes.
alephalpha
@zeldredge Trotzdem ist das nicht kürzer als die APL-Lösung.
FUZxxl
@alephalpha Alternativ können Sie U+F523( \[Implies]) verwenden, um es #∣4&&(#∣100<U+F523>#∣400)&für 19 Zeichen (aber immer noch 27 Byte) zu erstellen .
LegionMammal978
Dies ist eine Standardlücke. Sie verwenden eine Funktion, die genau die erforderliche Funktionalität erfüllt. Das ist verboten.
FUZxxl
6

R 29

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

Testlauf

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

C 81

Ich kann es kürzer machen, aber dieser hält sich ordentlich an 'char'-Typen, ohne das Argument zu analysieren (zB mit atoi):

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

Sie muss mit einem Namen von 4 Zeichen Länge aufgerufen werden, da standardmäßig davon ausgegangen wird, dass Argumente unmittelbar auf den Programmnamen folgen, getrennt durch NULs. Außerdem wird davon ausgegangen, dass das einzelne Argument in ASCII codiert ist und kein führendes Leerzeichen enthält.

Erläuterung:

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+9ist die Position der Zehnerstelle in v[1]+2.

Wenn die Zeichen 'Zehn' und 'Einheiten' zu 96 addieren, enden wir mit, sichern Sie 00also zwei Zeichen, sodass die Zeichen 'Zehn' und 'Einheiten' auf die Jahrhundertzahl verweisen.

Jetzt xor 'units' mit dem doppelten 'tens', mod 4. Dies funktioniert, weil 10==±2 mod 4das untere Bit der 'tens' nur Bit 1 der 'units' umschalten kann. Wir verwenden das Ergebnis als Index in unserer Resttabelle und drucken ynur, wenn das modulare Ergebnis Null ist.

Toby Speight
quelle
4

Befunge -98, (41 Bytes)

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

Einfachheit ist großartig.

MegaTom
quelle
4

sed, 55

s/00$//
y/0123456789/yNnNyNnNyN/
/N.$/y/ny/yn/
s/.\B//g
  • Die erste Zeile teilt die exakten Jahrhunderte durch 100.
  • Die zweite Zeile gibt 'N' für ungerade Ziffern, 'y' für 4s und 'n' für Nicht-4s.
  • Dritte Zeile vertauscht 'y' und 'n', wenn es eine ungerade vorletzte Ziffer gibt (weil 10 2 mod 4 ist)
  • Letzte Zeile löscht alle bis auf das letzte Zeichen

Beachten Sie, dass Nicht-Schaltjahre möglicherweise als noder Nabhängig davon gedruckt werden, ob sie gerade oder ungerade sind. Ich halte dies für eine kreative Interpretation der Regel, die Alternativen zu "Ja" und "Nein" zulässt, ohne dass angegeben wird, dass sie konsistent sein müssen.

Toby Speight
quelle
4

Python2 - 37

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

Beachten Sie, dass es sich bei if aum eine nicht negative Ganzzahl a<1handelt not bool(a). Der letzte <1wandelt den Ausdruck in den Klammern effektiv in einen Booleschen Wert um und negiert das Ergebnis.

Wenn Sie die Funktion gauf eine Ganzzahl nzwischen 1801 und 2400 anwenden, wird zurückgegeben, Truewenn nes sich um ein Schaltjahr handelt, Falseandernfalls.

mathmandan
quelle
3

KDB (Q), 27 Bytes

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

Erläuterung

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

Prüfung

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

Julia, 30 28 Bytes

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

Dadurch wird eine unbenannte Funktion erstellt, die ein ganzzahliges Argument akzeptiert und einen booleschen Wert zurückgibt. Um es zu nennen, geben Sie ihm einen Namen, z f=y->....

Ungolfed:

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

Beispiel:

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

PHP - 45 Bytes

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

Eigentlich nichts Besonderes, nur das Typ-Jonglieren zu missbrauchen.

Nord brücke
quelle
3

C #, 23 Bytes

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

Probieren Sie es online!

Vollständige Quelle, einschließlich Testfällen:

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
quelle
3

C 37, 34, 30 Bytes

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

Wandbox

o79y
quelle
3

T-SQL 37 22 Bytes

Dank BradCs Kommentar 15 Bytes gespart.

Die übliche fest codierte Variable mangels a stdin.

z.B

DECLARE @ NVARCHAR(4) = '2016'

Dann lautet die Lösung:

PRINT ISDATE(@+'0229')
S.Karras
quelle
1
Wenn ich die Herausforderung richtig lese, können Sie eine Menge Bytes sparen, indem Sie einfach das 1oder 0direkt zurückgeben:PRINT ISDATE(@+'0229')
BradC
3

Java 8, 49 45 22 20 Bytes

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

-2 Bytes dank @ OlivierGrégoire .

Probieren Sie es online aus.

Einige 22-Byte-Lösungen:

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

Probieren Sie es online aus.

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

Probieren Sie es online aus.

java.time.Year::isLeap

Probieren Sie es online aus.

Erläuterung:

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
quelle
Weitere 22 Bytes Alternative: java.time.Year::isLeap.
Olivier Grégoire
2
Und eine 20-Byte-Lösung:n->n%(n%25<1?16:4)<1
Olivier Grégoire
@ OlivierGrégoire Schöner 20er! Und wusste nicht, dass das eingebaute auch 22 Bytes war. :)
Kevin Cruijssen
2

Javascript ES6, 32, 29, 26

Jede der folgenden Zeilen funktioniert:

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
quelle
2

C 57 Bytes

Übernimmt die Eingabe von stdin mit oder ohne nachfolgende Leerzeichen / Zeilenumbrüche. Funktioniert nur auf kleinen Endian-Rechnern (ja, so wie heutzutage jeder BE betreibt). Ausgänge Y oder N.

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

Erläuterung

Ungolfed:

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

Zuerst scanfliest das Jahr als eine ganze Zahl in y. Dann wird y mit 4 oder 400 moduliert, je nachdem, ob das Jahr durch 100 teilbar ist. Wenn der Rest Null ist, wird der ASCII-Code für Y y zugewiesen, andernfalls wird der ASCII-Code für N abgerufen. Der Wert von y ist jetzt 0x000000??, wo 0x??ist das zugewiesene Zeichen. Wenn Sie sich auf einem Little-Endian-Computer befinden, wird dies im Speicher als gespeichert ?? 00 00 00. Dies ist eine mit NULL abgeschlossene C-Zeichenfolge, die nur die zugewiesenen Zeichen enthält. Die Adresse von y wird an Puts übergeben und das Zeichen wird gedruckt (mit einer nachgestellten Zeile).

Andrea Biondo
quelle
1
"Sie werden auf jede Art und Weise ausgeben, die Ihnen gefällt, und dem Benutzer klar sagen, ob es ein Schaltjahr ist oder nicht." Können Sie ein paar Bytes sparen, indem Sie 1 oder 0 anstelle von 'Y' oder 'N' zurückgeben? (Ich kenne C überhaupt nicht wirklich, rate nur.)
Alex A.
@AlexA. Danke für die Bearbeitung - jetzt weiß ich, wie man Syntax hervorhebt :) Ich habe darüber nachgedacht. Die ASCII-Codes sind beide zweistellig, daher ist das kein Vorteil (ich verwende übrigens Y und N in Großbuchstaben, um 2 Bytes zu sparen, da Kleinbuchstaben 3-stellig sind). Sie sind sequentiell, das könnte also nützlich sein. Leider bekommen, aufgrund Operatorpräzedenz, ich die gleichen Byte - Zählung: main(y){scanf("%d",&y);y=!(y%(y%100?4:400))+48;puts(&y);}. Ich kann auf 48 Bytes runter gehen, wenn ich eine leere Zeile für Schaltjahre und ein beliebiges Zeichen (ASCII 1-99) ausgeben kann, aber ich habe das Gefühl, dass es ein bisschen gegen die Regeln verstößt. Was denkst du?
Andrea Biondo
Ich muss beim Zählen der Zeichen etwas falsch gemacht haben. Es ist 57, nicht 59 :)
Andrea Biondo
1
Ja, ich würde sagen, das verstößt gegen die Regeln, aber Sie könnten die Frage kommentieren und das OP um Bestätigung bitten. Ein gutes Werkzeug zum Zählen von Bytes ist dies - ich denke, viele Leute hier verwenden es.
Alex A.
Nein, ich lasse es wie es ist :)
Andrea Biondo
2

PowerShell, 31 Byte

Ich freue mich zu sagen, dass ich dies kürzer als das eingebaute Golf gespielt habe!

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

Ausgänge für Schaltjahre wahr und ansonsten falsch.

Eingebaut:

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

Wollte ich die Aussage "Dem Benutzer klar sagen, ob es sich um ein Schaltjahr handelt oder nicht" strecken und etwas anderes tun, könnte ich 3 Bytes einsparen und Folgendes verwenden:

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

Diese Ausgabe erfolgt 0für Schaltjahre und 1 oder höher für Nicht-Schaltjahre, was mir nicht gefällt, da ich es vorziehen würde, für Schaltjahre einen normaleren Wahrheitswert zurückzugeben.

ThePoShWolf
quelle
2

LOLCODE, 228 202 159 Bytes

HOW IZ I f YR a
MOD OF a AN 100
O RLY?
YA RLY
MOD OF a AN 4
O RLY?
YA RLY
b R 1
OIC
NO WAI
MOD OF a AN 400
O RLY?
YA RLY
b R 0
NO WAI
b R 1
OIC
OIC
IF U SAY SO

Ungolfed:

HAI 1.3 BTW "HAI" does nothing functionally in current versions and does not throw an error if you omit it.
HOW IZ I leap YR input
    I HAS A output
    DIFFRINT MOD OF input AN 100 AN 0 BTW Thanks @LeakyNun, In LOLCODE any non-empty values, i.e. 0, "", etc. default to WIN.
    O RLY?
        YA RLY
            BOTH SAEM MOD OF a AN 4 AN 0
            O RLY?
                YA RLY
                    output R WIN BTW "WIN" is true, but in the actual program I used 1 as a truthy value because it's shorter.
            OIC
        NO WAI
            DIFFRINT MOD OF a AN 400 AN 0
            O RLY?
                YA RLY
                    output R FAIL BTW "Fail" is false, but in the actual program I used 0 as a falsy value.
                NO WAI
                    output R WIN
            OIC
    OIC
    FOUND YR output BTW This statement is implied in the golfed version.
IF U SAY SO BTW "KTHXBYE", just like "HAI" has no functional purpose and throws no error on omission.
KTHXBYE

In Python ungolfed, weil LOLCODE verwirrend ist:

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
quelle
Wäre es kürzer, eine Funktion zu definieren?
Undichte Nonne
wahrscheinlich, aber ich werde es später bearbeiten.
OldBunny2800
Sie haben den Hauptcode aktualisiert, um eine Funktion zu sein, aber nicht den ungolften Code?
Destructible Lemon
Ich dachte, LOLCODE hat automatischen Typenzwang, was bedeutet, dass jeder Wert ungleich Null gleichbedeutend ist mit WIN..
Undichte Nonne
Es ist, aber wie könnte ich das nutzen? Ich glaube nicht, dass ich Casting mache.
OldBunny2800