Bu zorluk oldukça basittir. 1801 - 2400 arasında bir yıl olacak bir girdi alacaksınız ve artık bir yıl olup olmadığına bakacaksınız.

Girişinizde yeni satır yok ya da sondaki boşluk yok:

1954

İstediğiniz şekilde, artık bir yıl olup olmadığını açıkça söyleyen bir şekilde çıktısını alacaksınız (evet / hayır için y veya n'yi kabul edeceğim)

Burada artık yılların bir listesini alabilirsiniz: http://kalender-365.de/leap-years.php Artık yılların her zaman dört yıl olmadığını not edeceğim. 1896 artık bir yıl, ancak 1900 değil. Bu "atlamayı" takip eden yıllar:

1900
2100
2200
2300

Test durumları:

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

EDIT: Bu standart bir Gregoryen takvimine dayanmaktadır: http://www.epochconverter.com/date-and-time/daynumbers-by-year.php

APL, 16 14 12 karakter

0Artık yıl için, artık 1olmayan bir yıl için döndürür .

≥/⌽×4 25 4⊤⎕

Bu çözümü tryapl.org adresinde deneyin . {≥/⌽×4 25 4⊤⍵}Tryapl.com'un desteklemediği için ⎕(kullanıcı girişi yap) çözümü dfn olarak değiştirdiğimi unutmayın . ⎕Boş bir kutu olduğuna dikkat edin , eksik bir karakter değil.

J de aynı çözüm:

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

açıklama

Dyadic ⊤(kodlamak), sol argümanı tarafından belirtilen tabandaki sağ argümanını temsil eder. 4 25 4Bu çözümde taban kullanıyorum . Bu y yılını polinom olarak temsil eder.

y mod 400 = 100 a + 4 b + c  burada b <100 ve c <4.

Önermeler olsun , P a, ve y ise temsil a, b ve c sıfır olmayan vardır: önerme γ yanlış ise y 4 ile bölünebilir olduğu, p ∧ γ durumunda yanlış Y 100 ve bölünebilir olan a ∧ p ∧ γ isimli y 400 ile bölünebilir ise false .

Bir doğruluk tablosu ( *“umrunda değil” ifadesini temsil eder) önerme Δ y'nin bir artık yıl elde edip etmediğini temsil eder:

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

Aşağıdaki ifade α , α , β ve γ olarak ifade eder :

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

Bu ifadenin yapısından dolayı, ≥/⌽α β γ← ←'u uygulayan azaltma olarak ifade edilebilir . Bu, şu an açıklayacağım cevaba yol açıyor.

Pyth, 11 bayt

!%|F_jQ*TT4

Bu tam program STDIN'den okunur ve artık yıllar boyunca True , aksi halde False yazdırılır .

Pyth'i önerdiği ve temel olarak CJam kodumu taşıdığı için @Jakube'e teşekkürler.

Test durumlarını Pyth Compiler / Executor'da kendiniz doğrulayın .

Nasıl çalışır

     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 bayt

rS+2m<~e|4%!

Bu tam program STDIN'den okunur ve artık yıllar için 1, aksi takdirde 0 yazdırır.

Test durumlarını CJam tercümanında kendiniz doğrulayın .

Nasıl çalışır

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 karakter

Standart kural, y4'ün bölünmesi yve 100'ün bölünmemesi yveya 400'ün bölünmesi durumunda artık bir yıldır y. Kodunda,

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

Buna 100 ve 400'e gerek yok. Bunun yerine 16 ya da 4'ün y'yi bölüp bölmediğini, 16 ise 25'i y, 4'ü seçerek kontrol etmeyi yeterli. Golf, bu olur

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

Bunu uygulayan bir javascript işlevi 21 karakter uzunluğundadır:

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

Perl, 28 26 karakter

Aynı fikir, ama perl.

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

-lpSeçenekleri kullanarak çalıştırın . Örneğin,

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

Test giriş olarak ayarlanmışsa, bu

1936
y
1805
n
1900
n
2272
y
2400
y

Pip , 13 bayt

Bu, ilk başta göründüğünden daha ilginçti. Bazı finagling aldı ama nihayet bu uzun başvuruları değiştirmek başardı 400ile 4ve hdeğişken (= 100).

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

1Artık yıl için çıktılar , artık 0olmayan yıl için. Açıklama:

               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 bayt

xFm!%Q^d2[2TyT

Yol çok kolay. Çevrimiçi deneyin: Gösteri veya Test koşum

edit: Missed, bunun yerine Truthy / Falsy değerlerini yazdırabilirsiniz n/y. -4 bayt

düzenleme 2: Martin'in karekök fikrini kullandım. -1 bayt

açıklama

                 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

Regex'in her iki yarısını birleştirmeyle ilgili ipuçları için Toby'ye teşekkürler.

Yalnızca 1801..2400 aralığına odaklanırsak ve girişin tamsayılar olduğunu varsayarsak:

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

İstediğiniz aralık için Ruby'de ( ^= \Ave $= \ZRuby olduğundan) test edin:

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) yalnızca 1801..2400 için değil, olumsuz bir yıl için de çalışması gereken şeyler için:

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

İlk 100000 yıl boyunca Ruby'de ( ^= \Ave $= \Zçünkü Ruby) test et :

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

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

Golf: !(y%100<1&&y%400||y%4)(özellikle De Morgans yasasını kullanarak )

Kuralı uygulayan bir işlev:

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

Emin olmak için bir test (Firefox'ta çalıştırın):

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

Belirlenmiş olduğu için, TI-BASIC genellikle basit matematik zorluklarında rekabetçidir, ancak “bölünebilir” bir komut olmadığından bu değil. Belki de sonuçta bu, ama bu hala CJam ve Pyth'tan daha uzun.

Bu, David Hammond'ın yöntemini kullanır.

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

16 byte'ta eski kod:

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("kesirli kısım" dır; üstelleştirme, bölmeden daha yüksek önceliğe sahiptir. TI-BASIC'de yakın parenler isteğe bağlıdır.

sub(Genellikle bir alt dize elde etmek için kullanılan komutun belgesiz davranışını kullanırım : argümanı bir dize yerine bir sayı olduğunda, sayıyı 100'e böler. Bir TI-83 veya 84 seri hesap makinesinde çalışır.

20 -> 17 yakın parenlerin çıkarılmasını sağlamak için kodu yeniden düzenleyerek; 17 -> 16'yı 400'ü 16 ile değiştirerek; 16 -> 13 David Hammond'un fikrini kullanarak.

Stackylogic, 226 bayt (yarışmayan)

Evet bu doğru. Burada bulunan meydan okuma için Helka Homba tarafından icat edilen Stackylogic'de (TC olmayan) bir program yaptım . Bu mücadeleden sonra yapılır, bu yüzden rekabet etmez.

Stackylogic sadece ikili girişe sahip olduğundan, 10 (veya daha fazla sayı, daha fazla rakam dikkate alınmayacaktır) bit ikili kullanılmalıdır (önce girilen en az anlamlı bit). Girilen numaranın ne olduğunu kontrol ettiği için belirtilen aralığın dışındaki herhangi bir tarih başarısız olabilir: gereksiz tarihleri ​​kapsamaz

Bu sadece stackylogic ile ilk mücadelem değil, aynı zamanda stackylogic ile ilk mücadelem.

Bu karmaşaya hazır olun:

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

Bu benim için çok uzun sürdü, çünkü Stackylogic karşılaştığım en kafa karıştırıcı dil ve son derece okunamıyor: Düzenlenmekte olan bölümü okuyabilmeniz için programın geri kalanının nasıl yürüdüğünü bilmek zorundasınız. Oluştururken okunabilirlik için boşluk eklemek zorunda kaldım.

Meager açıklaması

Bu ne yaptığının basit bir açıklamasıdır.

Stackylogic'in herhangi bir matematiksel işlevi yoktur, bu nedenle bunu zorlaştırır. Belirli bir sayı olup olmadığını kontrol etmek için çoğunu kodlamam gerekiyordu.

Birincisi, bu program en az önemli bitlerin NOR'unu yapacak ve bu süreçte bunları atacaktır. Bunun anlamı, eğer 4'e bölünebilirse, programın ana kısmına gidecektir, aksi halde 0 çıkacaktır.

İkincisi, işaretçi stackylogic'in labirentine taşınır, buradan sonraki iki bit sıfırsa, anında 1 çıkacaktır (o zamanki 16 ile bölünebilir ve diğer koşullara rağmen artık bir yıl). bilge, 4'e bölünebilecek sayıların olup olmadığına bakılmaksızın ancak artık yıl, 1801 ile 2400 arasında olup olmadığını kontrol edecektir.

Ayrıntılı olarak açıklamak gerekirse, bu gönderiyi olduğundan daha uzun sürelerle yapmak

IBM System Z assembler - 56 bayt.

(96 bayt kaynak. Önceden 712 384 202 bayt kaynak, 168 bayt çalıştırılabilir).

Küçük versiyon hala. Artık arayanın kayıtlarını, değişmez depolama alanında yapılan değişiklikleri, adresleme modunu değiştirmedi.

 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 

Yeni sürüm. Bu artık bir yılsa S0C1 ile ABEND, değilse de döngü olacaktır. Umarım bu sonucun belirtilmesi gerekliliğini yerine getirir.

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  

Tamam, o zaman en kısa değil (her ne kadar gerçek çalıştırılan koda ve yorumlayıcı boyutuna baksak bile ...)

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  

Çıktı:

Artık bir yıl için ABEND S0C1, değilse S222 (CPU süresi bittiğinde).

1936 Y 1805 N 1900 N 2272 Y 2400 Y

(birden çok kez çalıştırdığınızda)

CJam, 18 16 bayt

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

Verir 1Artık yıllarda ve için (truthy) 0aksi (falsy).

Tüm test durumlarını burada çalıştırın.

açıklama

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 bayt, 17 karakter

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

17 karakter, ancak 27 bayt kullanır. Bahşiş için @ alephalpha'ya teşekkür ederiz. Dikey çubukların aslında bölmeler için U + 2223 olduğunu unutmayın. İlgili <U+F523>karakter ile değiştirilmelidir.

R, 29

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

Test sürüşü

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

Daha kısa yapabilirim, ancak bu, argüman ayrıştırılmadan, 'char' türlerine özenle yapışıyor (örn. İle atoi):

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

4 karakter uzunluğunda bir adla çağrılmalıdır, çünkü argümanların derhal NUL'larla ayrılmış program adını takip ettiği standart varsayımını yapar. Ayrıca, tek bir argümanın ASCII'de kodlanmış olduğunu ve öncü boşluğu olmadığını varsayar.

Açıklama:

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'tens' basamağının konumu v[1]+2.

Eğer 'onlar' ve 'birimler' karakterleri 96'ya eklenirse, sona ereriz 00, bu yüzden iki karakter yedeklenir, böylece 'onlar' ve 'birimler' yüzyıl sayısını gösterir.

Şimdi, iki kez 'onlar' olan 'birimler', mod 4. Bu 10==±2 mod 4, çünkü 'onlar'ın alt bitinin' birimlerin 'bit 1'ini değiştirebilmesi için çalışır. Sonucu kalanlar tablomuza bir indeks olarak kullanıyoruz, ysadece modüler sonuç sıfırsa yazdırıyoruz .

Befunge -98, (41 bayt)

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

Sadelik harika.

sed, 55

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

• İlk satır, kesin yüzyılları 100'e böler.
• İkinci satır 'N' tuhaf rakamlara, 'y' ile 4s arasına ve 'n' ile 4 olmayan numaralar verir.
• Üçüncü satır, tuhaf bir penultimate rakamı varsa 'y' ve 'n' değiştirir (çünkü 10, 2 mod 4'tür)
• Son satır son karakterden başka tümünü siler

Artık olmayan yılların , düz veya tuhaf olmasına bağlı olarak nveya yazdırılabileceğini unutmayın N. Bunu, tutarlı olmaları gerektiğini belirtmeden alternatiflerin “evet” ve “hayır” a izin veren yaratıcı bir yorumu olduğunu düşünüyorum.

Python2 - 37

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

Eğer unutmayın anegatif olmayan bir tamsayı, sonra a<1yazı kısa yoludur not bool(a). Böylece sonuncusu <1parantez içindeki ifadeyi bir boole dönüştürür ve sonucu olumsuzlar.

Fonksiyonunu uygulamak gbir tam sayıya n1801 ve 2400 arasında dönecektir Trueeğer nartık yıl olduğunu ve Falseaksi.

KDB (Q), 27 bayt

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

açıklama

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

Ölçek

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

Julia, 30 28 bayt

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

Bu, bir tamsayı argümanını kabul eden ve bir boole değeri döndüren adsız bir işlev oluşturur. Aramak için bir isim verin, örneğin f=y->....

Ungolfed:

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

Örnek:

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

PHP - 45 bayt

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

Gerçekten özel olan hiçbir şey yok, sadece tip hokkabazlık kötüye.

C #, 23 bayt

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

Çevrimiçi deneyin!

Test vakaları dahil tam kaynak:

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 3430 bayt

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

Wandbox

T-SQL 37 22 bayt

BradC'nin yorumu sayesinde 15 bayt kurtarıldı.

Her zamanki kodlanmış değişken a stdin.

Örneğin

DECLARE @ NVARCHAR(4) = '2016'

O zaman çözüm:

PRINT ISDATE(@+'0229')

Java 8, 49 45 22 20 bayt

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

@ OlivierGrégoire sayesinde -2 bayt .

Çevrimiçi deneyin.

Bazı 22 baytlık çözümler:

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

Çevrimiçi deneyin.

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

Çevrimiçi deneyin.

java.time.Year::isLeap

Çevrimiçi deneyin.

Açıklama:

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 bayt

f i=gcd 80i>gcd 50i

Çevrimiçi deneyin!

Javascript ES6, 32, 29, 26

Aşağıdaki satırlardan herhangi biri çalışır:

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 bayt

Girdiyi, stdin'den takip eden boşluk / newline ile veya bu satırdan alır. Sadece küçük endian makinelerinde çalışır (evet, bugünlerde herkes BE'de olduğu gibi). Y veya N çıkışları

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

açıklama

Ungolfed:

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

İlk olarak, scanfyılı y cinsinden bir tam sayı olarak okur. Daha sonra y, 100'e bölünebilir olup olmadığına bağlı olarak y, 4 veya 400 ile modulo'lanır. şimdi 0x000000??, 0x??atanan karakter nerede . Küçük bir endian makinesinde olmak, bellekte bu saklanır ?? 00 00 00. Bu, yalnızca atanmış karakterleri içeren NULL-sonlandırılmış bir C dizesidir. Y adresi koyarlara iletilir ve karakter basılır (izleyen bir yeni satırla).

PowerShell, 31 bayt

Yerleşikten daha kısa golf oynadığımı söyleyeceğim için heyecanlıyım!

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

Çıktılar yıllarca doğru, aksi takdirde yanlış.

yerleşik:

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

Her ne kadar, 'Kullanıcıya artık bir yıl olup olmadığını açıkça söyler' ifadesini genişletmek ve standart dışı bir şey yapmak istersem, 3 bayt kurtarabilir ve kullanabilirim:

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

Bu 0, artık yıllar için daha fazla standart truthy değeri döndürmeyi tercih ettiğimden hoşlanmadığım artık yıllar için çıktığım ve artık olmayan yıllar için 1 veya daha yüksek çıktılar .

LOLCODE, 228 202 159 bayt

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

Ungolfed:

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

Python unungolfed'de, çünkü LOLCODE kafa karıştırıcıdır:

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