Tantangan ini cukup sederhana. Anda akan mengambil input yang akan menjadi satu tahun dari 1801 hingga 2400, dan menghasilkan apakah tahun kabisat atau tidak.

Masukan Anda tidak akan memiliki baris baru atau spasi tambahan:

1954

Anda akan menampilkan dengan cara apa pun yang Anda suka yang dengan jelas memberi tahu pengguna apakah ini tahun kabisat atau tidak (saya akan menerima y atau n untuk ya / tidak)

Anda bisa mendapatkan daftar tahun kabisat di sini: http://kalender-365.de/leap-years.php Saya akan mencatat bahwa tahun kabisat tidak selalu empat tahun selalu. 1896 adalah tahun kabisat, tetapi 1900 tidak. Tahun-tahun yang mengikuti "lewati" ini adalah:

1900
2100
2200
2300

Kasus uji:

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

EDIT: Ini didasarkan pada kalender Gregorian standar: http://www.epochconverter.com/date-and-time/daynumbers-by-year.php

APL, 16 14 12 karakter

Pengembalian 0untuk tahun kabisat, 1untuk tahun yang tidak kabisat.

≥/⌽×4 25 4⊤⎕

Coba solusi ini di tryapl.org . Perhatikan bahwa saya telah mengubah solusi ke dfn {≥/⌽×4 25 4⊤⍵}karena tryapl.com tidak mendukung ⎕(ambil input pengguna). Perhatikan bahwa itu ⎕adalah kotak kosong, bukan karakter yang hilang.

Solusi yang sama dalam J:

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

Penjelasan

Dyadic ⊤(encode) mewakili argumen kanannya di dasar yang ditentukan oleh argumen kirinya. Saya menggunakan basis 4 25 4dalam solusi ini. Ini mewakili tahun y sebagai polinomial

y mod 400 = 100 a + 4 b + c di  mana b <100 dan c <4.

Biarkan proposisi α, β, dan γ mewakili jika a, b, dan c adalah nol: Proposisi γ salah jika y dapat dibagi dengan 4, β ∧ γ salah jika y dapat dibagi dengan 100 dan α ∧ β ∧ γ adalah false jika y dapat dibagi dengan 400.

Sebuah tabel kebenaran ( *mewakili “tidak peduli”) adalah proposisi Δ mewakili jika y adalah lompatan-tahun Memperoleh:

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

Pernyataan berikut ini menyatakan Δ dalam α , β , dan γ :

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

Karena struktur pernyataan ini, seseorang dapat menyatakan ¬Δ sebagai reduksi di ≥/⌽α β γmana ≥ mengimplementasikan ←. Ini mengarah pada jawaban yang saya jelaskan sekarang.

Pyth, 11 byte

!%|F_jQ*TT4

Program lengkap ini membaca dari STDIN dan mencetak True untuk tahun kabisat dan False sebaliknya.

Terima kasih kepada @Jakube untuk menyarankan Pyth dan pada dasarnya porting kode CJam saya.

Verifikasi sendiri kasus uji di Pyth Compiler / Executor .

Bagaimana itu bekerja

     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 byte

rS+2m<~e|4%!

Program lengkap ini membaca dari STDIN dan mencetak 1 untuk tahun kabisat dan 0 sebaliknya.

Verifikasi sendiri kasus uji dalam juru bahasa CJam .

Bagaimana itu bekerja

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

Aturan standar adalah bahwa itu yadalah tahun kabisat jika 4 membagi ydan jika 100 tidak membagi yatau 400 tidak membagi y. Dalam kode,

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

Tidak perlu untuk itu 100 dan 400. Sebaliknya cukup untuk memeriksa apakah 16 atau 4 membagi y, dengan 16 dipilih jika 25 membagi y, 4 sebaliknya. Golf, ini menjadi

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

Fungsi javascript yang mengimplementasikan ini sepanjang 21 karakter:

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

Perl, 28 26 karakter

Ide yang sama, tetapi dalam perl.

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

Jalankan menggunakan -lpopsi. Sebagai contoh,

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

Dengan set tes sebagai input, ini menghasilkan

1936
y
1805
n
1900
n
2272
y
2400
y

Pip , 13 byte

Yang ini lebih menarik daripada yang pertama kali muncul. Butuh beberapa penyelesaian, tapi akhirnya saya bisa mengganti referensi panjang 400dengan 4dan hvariabel (= 100).

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

Output 1untuk tahun kabisat, 0untuk tahun tidak kabisat. Penjelasan:

               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 byte

xFm!%Q^d2[2TyT

Terlalu mudah. Cobalah secara online: Demonstrasi atau Uji harness

edit: Tidak Terjawab, bahwa Anda dapat mencetak nilai-nilai Kebenaran / Kebohongan, bukan n/y. -4 byte

sunting 2: Menggunakan ide akar kuadrat dari Martin. -1 byte

Penjelasan

                 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

Terima kasih kepada Toby untuk tips tentang menggabungkan kedua bagian regex.

Jika kita fokus hanya pada kisaran 1801..2400 dan menganggap input bilangan bulat:

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

Tes di Ruby ( ^= \Adan $= \Zkarena Ruby) untuk rentang yang diinginkan:

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) untuk sesuatu yang seharusnya bekerja tidak hanya untuk 1801..2400, tetapi untuk tahun non-negatif:

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

Tes di Ruby ( ^= \Adan $= \Zkarena Ruby) untuk 100000 tahun pertama:

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

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

Golf: !(y%100<1&&y%400||y%4)(terutama menggunakan hukum De Morgans )

Fungsi yang menerapkan aturan:

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

Tes (jalankan di Firefox) hanya untuk memastikan:

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

Karena itu tokenized, TI-BASIC sering kompetitif di tantangan matematika sederhana, tetapi tidak yang ini karena tidak ada perintah "habis dibagi". Mungkin memang, tapi ini masih lebih lama dari CJam dan Pyth.

Ini menggunakan metode David Hammond.

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

Kode lama 16 byte:

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

Tidak Disatukan:

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

fPart(adalah "bagian pecahan"; eksponensial memiliki prioritas lebih tinggi daripada divisi. Dalam TI-BASIC, close-parens adalah opsional.

Saya menggunakan perilaku sub(perintah tidak berdokumen , biasanya digunakan untuk mendapatkan substring: ketika argumennya adalah angka dan bukan string, itu membagi angka dengan 100. Ini akan bekerja pada kalkulator seri TI-83 atau 84.

20 -> 17 dengan mengatur ulang kode untuk memungkinkan penghapusan parens dekat; 17 -> 16 dengan mengganti 400 dengan 16; 16 -> 13 dengan menggunakan ide David Hammond.

Stackylogic, 226 byte (tidak bersaing)

Ya itu benar. Saya membuat program di Stackylogic (non-TC), yang diciptakan oleh Helka Homba, untuk tantangan yang ditemukan di sini . Ini dibuat setelah tantangan, jadi non-bersaing.

Stackylogic hanya memiliki input biner, jadi 10 (atau lebih, lebih banyak digit akan diabaikan) bit biner harus digunakan (bit paling sedikit diinput dulu). Setiap tanggal di luar rentang yang ditentukan mungkin gagal, karena hanya memeriksa apa nomor yang dimasukkan: tidak mencakup tanggal yang tidak perlu

Tidak hanya ini tantangan pertama saya dengan stackylogic, tetapi tantangan pertama dengan stackylogic sama sekali.

Bersiaplah untuk kekacauan ini:

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

Ini membuat saya begitu lama untuk membuat, karena Stackylogic adalah bahasa yang paling membingungkan yang saya temui, dan sangat tidak dapat dibaca: Anda harus tahu bagaimana sisa program telah dijalankan sebelum Anda dapat membaca bagian saat ini sedang diedit. Saya bahkan harus menambahkan spasi untuk dibaca saat membuatnya.

Penjelasan kecil

Ini adalah penjelasan sederhana tentang apa yang dilakukannya.

Stackylogic tidak memiliki fungsi matematika, sehingga membuat ini lebih sulit. Saya harus hardcode sebagian besar, untuk memeriksa apakah itu nomor tertentu.

Pertama, program ini akan melakukan NOR dari bit paling tidak signifikan, membuangnya dalam proses. ini berarti bahwa jika itu dapat dibagi 4, itu akan melanjutkan ke bagian utama dari program, jika tidak output 0.

Kedua, pointer dibawa ke labirin stackylogic, dari sini, jika dua bit berikutnya adalah nol, maka akan langsung menghasilkan 1 (saat itu dapat dibagi oleh 16, dan jadi tahun kabisat terlepas dari kondisi lain), lainnya bijaksana itu akan memeriksa apakah itu bukan nomor yang dapat dibagi oleh 4 tetapi bukan tahun kabisat, antara 1801 dan 2400.

Untuk menjelaskan secara rinci, akan melibatkan membuat posting ini berkali-kali lebih lama dari yang sudah ada

Assembler IBM System Z - 56 byte.

(96 byte sumber. Sebelumnya 712 384 202 byte sumber, dapat dieksekusi 168 byte).

Versi yang lebih kecil. Tidak lagi menyimpan register pemanggil, perubahan ke penyimpanan literal, mengubah mode pengalamatan.

 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 

Versi baru. Ini akan MENGGANTI dengan S0C1 jika tahun kabisat, dan mengulang jika tidak. Semoga memenuhi persyaratan menunjukkan hasil.

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, jadi bukan yang terpendek (meskipun mungkin begitu kita melihat kode yang sebenarnya dieksekusi ditambah ukuran interpreter ...)

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  

Keluaran:

ABEND S0C1 selama satu tahun kabisat, S222 (saat waktu CPU telah habis) jika tidak.

1936 Y 1805 N 1900 N 2272 Y 2400 Y

(saat dijalankan beberapa kali)

CJam, 18 16 byte

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

Memberi 1(kebenaran) selama tahun kabisat dan 0(kepalsuan) sebaliknya.

Jalankan semua test case di sini.

Penjelasan

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

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

Menggunakan 17 karakter, tetapi 27 byte. Terima kasih kepada @alephalpha untuk tipnya. Perhatikan bahwa bilah vertikal sebenarnya adalah U + 2223 untuk pembagian. The <U+F523>harus diganti dengan karakter yang sesuai.

R, 29

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

Uji coba

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

Saya bisa melakukan yang lebih pendek, tetapi yang ini tetap dengan tipe 'char', tanpa menguraikan argumen (misalnya dengan atoi):

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

Itu harus dipanggil dengan nama 4 karakter, karena itu membuat asumsi standar bahwa argumen segera mengikuti nama program, dipisahkan oleh NUL. Lebih jauh, ini mengasumsikan bahwa argumen tunggal dikodekan dalam ASCII dan tidak memiliki ruang terdepan.

Penjelasan:

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+9adalah posisi digit 'puluhan' di v[1]+2.

Jika karakter 'puluhan' dan 'unit' ditambahkan ke 96, kita berakhir di 00, jadi buat cadangan dua karakter, sehingga 'puluhan' dan 'unit' menunjuk ke angka abad.

Sekarang xor 'unit' dengan dua kali 'puluhan', mod 4. Ini berfungsi karena 10==±2 mod 4, jadi bit yang lebih rendah dari 'puluhan' hanya dapat beralih bit 1 dari 'unit'. Kami menggunakan hasilnya sebagai indeks ke tabel sisa kami, mencetak yhanya jika hasil modular adalah nol.

Befunge -98, (41 byte)

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

Kesederhanaan itu luar biasa.

sed, 55

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

• Baris pertama membagi abad yang tepat dengan 100.
• Baris kedua memberikan 'N' ke digit ganjil, 'y' ke 4s, dan 'n' ke non-4s.
• Baris ketiga menukar 'y' dan 'n' jika ada digit kedua dari belakang yang aneh (karena 10 adalah 2 mod 4)
• Baris terakhir menghapus semua kecuali karakter terakhir

Perhatikan bahwa tahun non-kabisat dapat dicetak sebagai natau Ntergantung pada apakah mereka genap atau ganjil. Saya menganggap ini sebagai interpretasi kreatif dari aturan yang memungkinkan alternatif untuk 'ya' dan 'tidak' tanpa menyebutkan bahwa mereka harus konsisten.

Python2 - 37

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

Perhatikan bahwa jika abilangan bulat tidak negatif, maka a<1cara menulisnya singkat not bool(a). Yang terakhir <1dengan demikian secara efektif mengubah ekspresi dalam tanda kurung menjadi boolean dan meniadakan hasilnya.

Menerapkan fungsi gke integer nantara 1801 dan 2400 akan kembali Truejika nmerupakan tahun kabisat, dan Falsesebaliknya.

KDB (Q), 27 byte

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

Penjelasan

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

Uji

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

Julia, 30 28 byte

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

Ini menciptakan fungsi tanpa nama yang menerima argumen integer dan mengembalikan nilai boolean. Untuk menyebutnya, berikan nama, mis f=y->....

Tidak Disatukan:

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

Contoh:

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

PHP - 45 byte

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

Tidak ada yang istimewa benar-benar, hanya penyalahgunaan juggling.

C #, 23 byte

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

Cobalah online!

Sumber lengkap, termasuk uji kasus:

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 byte

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

Wandbox

T-SQL 37 22 byte

Disimpan 15 byte berkat komentar BradC.

Variabel hardcoded biasa karena kurangnya a stdin.

misalnya

DECLARE @ NVARCHAR(4) = '2016'

Maka solusinya adalah:

PRINT ISDATE(@+'0229')

Java 8, 49 45 22 20 byte

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

-2 byte terima kasih kepada @ OlivierGrégoire .

Cobalah online.

Beberapa solusi 22 byte:

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

Cobalah online.

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

Cobalah online.

java.time.Year::isLeap

Cobalah online.

Penjelasan:

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 byte

f i=gcd 80i>gcd 50i

Cobalah online!

Javascript ES6, 32, 29, 26

Setiap baris berikut berfungsi:

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 byte

Mengambil input dari stdin, dengan atau tanpa spasi tambahan / baris baru. Hanya bekerja pada mesin endian kecil (ya, seperti semua orang di BE hari ini). Output Y atau N.

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

Penjelasan

Tidak Disatukan:

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

Pertama, scanfbaca tahun sebagai bilangan bulat di y. Kemudian, y adalah modulo'ed dengan 4 atau 400 tergantung pada apakah tahun tersebut dapat dibagi 100. Jika sisanya adalah nol, kode ASCII untuk Y ditugaskan ke y, jika tidak maka akan mendapatkan kode ASCII untuk N. Nilai dari y sekarang 0x000000??, di mana 0x??karakter yang ditugaskan. Berada di mesin little-endian, dalam memori ini disimpan sebagai ?? 00 00 00. Ini adalah string C diakhiri NULL, hanya berisi karakter yang ditugaskan. Alamat y diteruskan ke put dan char dicetak (dengan baris baru)

PowerShell, 31 byte

Saya senang mengatakan bahwa saya bermain golf ini lebih pendek dari builtin!

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

Output benar untuk tahun kabisat dan false jika tidak.

Dibangun:

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

Padahal, jika saya ingin meregangkan pernyataan 'dengan jelas memberi tahu pengguna apakah tahun kabisat atau bukan' dan melakukan sesuatu yang tidak standar, saya bisa menghemat 3 byte dan menggunakan:

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

Ini menghasilkan 0untuk tahun kabisat dan 1 atau lebih tinggi untuk tahun tidak kabisat, yang saya tidak suka karena saya lebih suka mengembalikan nilai kebenaran standar yang lebih untuk tahun kabisat.

LOLCODE, 228 202 159 byte

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

Tidak Disatukan:

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

Dalam Python ungolfed, karena LOLCODE membingungkan:

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