Thử thách này khá đơn giản. Bạn sẽ có một đầu vào sẽ là một năm từ 1801 đến 2400 và đầu ra nếu đó là một năm nhuận hay không.

Đầu vào của bạn sẽ không có dòng mới hoặc dấu cách:

1954

Bạn sẽ xuất ra theo bất kỳ cách nào bạn thích mà nói rõ cho người dùng biết nếu đó là hoặc không phải là năm nhuận (tôi sẽ chấp nhận y hoặc n cho có / không)

Bạn có thể nhận được một danh sách các năm nhuận ở đây: http://kalender-365.de/leap-years.php Tôi sẽ lưu ý rằng năm nhuận không bao giờ là bốn năm luôn luôn. 1896 là một năm nhuận, nhưng 1900 thì không. Những năm sau "bỏ qua" này là:

1900
2100
2200
2300

Các trường hợp thử nghiệm:

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

EDIT: Điều này dựa trên lịch Gregorian tiêu chuẩn: http://www.epochconverter.com/date-and-time/daynumbers-by-year.php

APL, 16 14 12 ký tự

Trả về 0một năm nhuận, 1cho một năm không nhuận.

≥/⌽×4 25 4⊤⎕

Hãy thử giải pháp này trên tryapl.org . Lưu ý rằng tôi đã thay đổi giải pháp cho dfn {≥/⌽×4 25 4⊤⍵}vì tryapl.com không hỗ trợ ⎕(lấy đầu vào của người dùng). Lưu ý rằng đó ⎕là một hộp trống, không phải là một ký tự bị thiếu.

Giải pháp tương tự trong J:

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

Giải trình

Dyadic ⊤(mã hóa) đại diện cho đối số bên phải của nó trong cơ sở được chỉ định bởi đối số bên trái của nó. Tôi sử dụng cơ sở 4 25 4trong giải pháp này. Điều này đại diện cho năm y là một đa thức

y mod 400 = 100 a + 4 b + c  trong đó b <100 và c <4.

Hãy mệnh đề a, β, và gamma đại diện nếu một, b, và c đều là phòng không không: Dự γ là false nếu y là dividable 4, β ∧ γ là false nếu y là dividable 100 và alpha ∧ β ∧ γ là sai nếu y được chia cho 400.

Một bảng chân lý ( *đại diện cho những người không quan tâm, đã đề xuất Δ đại diện nếu y là một năm nhuận đạt được:

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

Tuyên bố sau đây thể hiện Δ trong α , β , và γ :

Δ = ¬ (( alpha → beta ) → gamma )).

Do cấu trúc của tuyên bố này, người ta có thể biểu thị ¬Δ là mức giảm ≥/⌽α β γtrong đó thực hiện ←. Điều này dẫn đến câu trả lời tôi đang giải thích ngay bây giờ.

Bình thường, 11 byte

!%|F_jQ*TT4

Chương trình đầy đủ này đọc từ STDIN và in True cho năm nhuận và Sai khác.

Cảm ơn @Jakube đã gợi ý Pyth và về cơ bản chuyển mã CJam của tôi.

Tự kiểm tra các trường hợp kiểm tra trong Trình biên dịch / thực thi Pyth .

Làm thế nào nó hoạt động

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

Chương trình đầy đủ này đọc từ STDIN và in 1 cho năm nhuận và 0 nếu không.

Tự kiểm tra các trường hợp kiểm tra trong trình thông dịch CJam .

Làm thế nào nó hoạt động

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 ký tự

Quy tắc chuẩn là ynăm nhuận nếu 4 chia yvà nếu 100 không chia yhoặc 400 không chia y. Trong mã,

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

Không cần 100 và 400. Thay vào đó, nó đủ để kiểm tra xem 16 hoặc 4 chia y, với 16 được chọn nếu 25 chia y, 4 nếu không. Chơi gôn, điều này trở thành

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

Một hàm javascript thực hiện điều này dài 21 ký tự:

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

Perl, 28 26 ký tự

Cùng một ý tưởng, nhưng trong perl.

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

Chạy bằng các -lptùy chọn. Ví dụ,

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

Với thử nghiệm được đặt làm đầu vào, điều này tạo ra

1936
y
1805
n
1900
n
2272
y
2400
y

Pip , 13 byte

Điều này là thú vị hơn nó lần đầu tiên xuất hiện. Phải mất một số tiền phạt, nhưng cuối cùng tôi đã có thể thay thế các tham chiếu dài đó 400bằng 4và hbiến (= 100).

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

Đầu ra 1cho năm nhuận, 0cho năm không nhuận. Giải trình:

               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

Cách quá dễ dàng. Dùng thử trực tuyến: Trình diễn hoặc thử nghiệm khai thác

chỉnh sửa: Mất tích, thay vào đó bạn có thể in các giá trị Truthy / Falsy n/y. -4 byte

chỉnh sửa 2: Sử dụng ý tưởng căn bậc hai của Martin. -1 byte

Giải trình

                 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

Chính quy, 83 62 38

Cảm ơn Toby cho lời khuyên về việc kết hợp cả hai nửa của regex.

Nếu chúng tôi chỉ tập trung vào phạm vi 1801..2400 và giả sử đầu vào là số nguyên:

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

Kiểm tra trong Ruby ( ^= \Avà $= \Zvì Ruby) cho phạm vi mong muốn:

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

(Tiền thưởng) cho một thứ gì đó sẽ hoạt động không chỉ trong năm 1801..2400, mà cho bất kỳ năm không âm nào:

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

Thử nghiệm trong Ruby ( ^= \Avà $= \Zvì Ruby) trong 100000 năm đầu tiên:

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

Quy tắc: (y%4==0) && (y%100!=0 || y%400==0)

Chơi gôn: !(y%100<1&&y%400||y%4)(chủ yếu sử dụng luật của De Morgans )

Một hàm thực hiện quy tắc:

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

Một thử nghiệm (chạy trong Firefox) chỉ để chắc chắ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

Do được token hóa, TI-BASIC thường cạnh tranh ở các thử thách toán học đơn giản, nhưng không phải là thử thách này vì không có lệnh "chia hết". Có thể đó là sau tất cả, nhưng điều này vẫn còn dài hơn cả CJam và Pyth.

Điều này sử dụng phương pháp của David Hammond.

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

Mã cũ ở 16 byte:

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

Ung dung:

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

fPart(là "phần phân số"; lũy thừa có độ ưu tiên cao hơn phép chia. Trong TI-BASIC, parens gần là tùy chọn.

Tôi sử dụng hành vi không có giấy tờ của sub(lệnh, thường được sử dụng để lấy chuỗi con: khi đối số của nó là một số thay vì một chuỗi, nó chia số cho 100. Nó sẽ hoạt động trên máy tính sê-ri TI-83 hoặc 84.

20 -> 17 bằng cách sắp xếp lại mã để cho phép loại bỏ các parens gần; 17 -> 16 bằng cách thay 400 bằng 16; 16 -> 13 bằng cách sử dụng ý tưởng của David Hammond.

Stackylogic, 226 byte (không cạnh tranh)

Vâng, đó là đúng. Tôi đã thực hiện một chương trình trong Stackylogic (không phải TC), được phát minh bởi Helka Homba, cho thử thách được tìm thấy ở đây . Điều này được thực hiện sau khi thử thách, vì vậy không cạnh tranh.

Stackylogic chỉ có đầu vào nhị phân, vì vậy 10 (hoặc nhiều hơn, bất kỳ chữ số nào sẽ bị bỏ qua) nhị phân bit phải được sử dụng (bit đầu vào ít nhất đáng kể được nhập trước). Bất kỳ ngày nào nằm ngoài phạm vi được chỉ định có thể không thành công, vì nó chỉ đơn giản kiểm tra số được nhập là gì: nó không bao gồm các ngày không cần thiết

Đây không chỉ là thử thách đầu tiên của tôi với stackylogic, mà còn là thử thách đầu tiên với stackylogic.

Hãy sẵn sàng cho mớ hỗn độn này:

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

Điều này khiến tôi mất quá nhiều thời gian để thực hiện, bởi vì Stackylogic là ngôn ngữ khó hiểu nhất mà tôi gặp phải và cực kỳ khó đọc: bạn phải biết phần còn lại của chương trình đã thực thi như thế nào trước khi bạn có thể đọc phần hiện tại đang được chỉnh sửa. Tôi thậm chí đã phải thêm không gian để dễ đọc trong khi tạo nó.

Giải thích ít ỏi

Đây là một lời giải thích đơn giản về những gì nó làm.

Stackylogic không có bất kỳ chức năng toán học nào, do đó làm cho việc này khó hơn. Tôi đã phải mã hóa hầu hết số đó, để kiểm tra xem đó có phải là một con số cụ thể không.

Đầu tiên, chương trình này sẽ thực hiện một số bit ít quan trọng nhất, loại bỏ chúng trong quy trình. điều này có nghĩa là nếu nó chia hết cho 4, nó sẽ tiến tới phần chính của chương trình, nếu không thì xuất 0.

Thứ hai, con trỏ được chuyển đến mê cung của stackylogic, từ đây, nếu hai bit tiếp theo bằng 0, nó sẽ ngay lập tức xuất ra 1 (khi đó nó chia hết cho 16, và do đó, một năm nhuận bất chấp các điều kiện khác), khác khôn ngoan nó sẽ kiểm tra nếu nó không phải là bất kỳ số nào chia hết cho 4 nhưng không phải là năm nhuận, trong khoảng từ 1801 đến 2400.

Để giải thích chi tiết, sẽ liên quan đến việc làm cho bài đăng này dài hơn nhiều lần so với nó

Trình biên dịch hệ thống IBM Z - 56 byte.

(96 byte nguồn. Trước đây 712 384 202 byte nguồn, thực thi 168 byte).

Phiên bản nhỏ hơn vẫn còn. Không còn lưu các thanh ghi của người gọi, thay đổi thành lưu trữ theo nghĩa đen, thay đổi chế độ địa chỉ.

 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 

Phiên bản mới. Điều này sẽ TRÊN với S0C1 nếu đó là năm nhuận và lặp lại nếu không. Hy vọng rằng đáp ứng yêu cầu chỉ ra kết quả.

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, vì vậy không phải là ngắn nhất (mặc dù có thể là một khi chúng ta nhìn vào mã được thực thi thực tế cộng với kích thước trình thông dịch ...)

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  

Đầu ra:

ABEND S0C1 cho một năm nhuận, S222 (khi hết thời gian CPU) nếu không.

1936 Y 1805 N 1900 N 2272 Y 2400 Y

(khi chạy nhiều lần)

CJam, 18 16 byte

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

Cung cấp 1(trung thực) cho năm nhuận và 0(giả) khác.

Chạy tất cả các trường hợp thử nghiệm ở đây.

Giải trình

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.

Toán học, 40 27 byte, 17 ký tự

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

Sử dụng 17 ký tự, nhưng 27 byte. Cảm ơn @alephalpha cho tiền boa. Lưu ý rằng các thanh dọc thực sự là U + 2223 cho các phép chia. Các <U+F523>nên được thay thế bằng các nhân vật tương ứng.

R, 29

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

Chạy thử nghiệm

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

Tôi có thể thực hiện ngắn hơn, nhưng cách này gọn gàng theo kiểu 'char', mà không phân tích cú pháp đối số (ví dụ: với atoi):

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

Nó phải được gọi với một tên dài 4 ký tự, bởi vì nó đưa ra giả định chuẩn rằng các đối số ngay lập tức theo tên chương trình, được phân tách bằng NUL. Hơn nữa, nó giả định rằng đối số duy nhất được mã hóa trong ASCII và không có không gian hàng đầu.

Giải trình:

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+9là vị trí của chữ số 'hàng chục' trong v[1]+2.

Nếu các ký tự 'hàng chục' và 'đơn vị' thêm vào 96, chúng ta sẽ kết thúc 00, sao lưu hai ký tự, sao cho 'hàng chục' và 'đơn vị' trỏ đến số thế kỷ.

Bây giờ xor 'đơn vị' với hai lần 'hàng chục', mod 4. Điều này hoạt động bởi vì 10==±2 mod 4, do đó, bit thấp hơn của 'hàng chục' chỉ có thể chuyển đổi bit 1 của 'đơn vị'. Chúng tôi sử dụng kết quả dưới dạng chỉ mục vào bảng phần còn lại của mình, ychỉ in nếu kết quả mô-đun bằng không.

Befunge -98, (41 byte)

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

Đơn giản là tuyệt vời.

sed, 55

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

• Dòng đầu tiên chia thế kỷ chính xác cho 100.
• Dòng thứ hai cung cấp 'N' cho các chữ số lẻ, 'y' thành 4s và 'n' cho các số không.
• Dòng thứ ba hoán đổi 'y' và 'n' nếu có một chữ số áp chót kỳ lạ (vì 10 là 2 mod 4)
• Dòng cuối cùng xóa tất cả trừ ký tự cuối cùng

Lưu ý rằng năm không nhuận có thể được in dưới dạng nhoặc Ntùy thuộc vào số chẵn hay lẻ. Tôi coi đây là một cách giải thích sáng tạo của quy tắc cho phép các lựa chọn thay thế 'có' và 'không' mà không xác định rằng chúng phải nhất quán.

Python2 - 37

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

Lưu ý rằng nếu alà một số nguyên không âm, thì đó a<1là một cách viết ngắn not bool(a). <1Do đó, cuối cùng có hiệu quả chuyển đổi biểu thức trong ngoặc đơn thành boolean và phủ nhận kết quả.

Áp dụng hàm gcho một số nguyên ntrong khoảng từ 1801 đến 2400 sẽ trả về Truenếu nlà năm nhuận và Falsengược lại.

KDB (Q), 27 byte

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

Giải trình

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

Kiểm tra

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

Điều này tạo ra một hàm không tên chấp nhận một đối số nguyên và trả về giá trị boolean. Để gọi nó, đặt tên cho nó, vd f=y->....

Ung dung:

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

Thí dụ:

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

Không có gì đặc biệt thực sự, chỉ lạm dụng kiểu tung hứng.

C #, 23 byte

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

Hãy thử trực tuyến!

Nguồn đầy đủ, bao gồm các trường hợp thử nghiệm:

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;}

Cây đũa phép

T-SQL 37 22 byte

Đã lưu 15 byte nhờ bình luận của BradC.

Biến mã hóa thông thường cho thiếu a stdin.

ví dụ

DECLARE @ NVARCHAR(4) = '2016'

Sau đó, giải pháp là:

PRINT ISDATE(@+'0229')

Java 8, 49 45 22 20 byte

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

-2 byte nhờ @ OlivierGrégoire .

Hãy thử trực tuyến.

Một số giải pháp 22 byte:

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

Hãy thử trực tuyến.

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

Hãy thử trực tuyến.

java.time.Year::isLeap

Hãy thử trực tuyến.

Giải trình:

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

Hãy thử trực tuyến!

Javascript ES6, 32, 29, 26

Bất kỳ dòng nào sau đây hoạt động:

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

Lấy đầu vào từ stdin, có hoặc không có dấu cách / dòng mới. Chỉ hoạt động trên các máy endian nhỏ (vâng, giống như mọi người đang ở trên BE những ngày này). Đầu ra Y hoặc N.

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

Giải trình

Ung dung:

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

Đầu tiên, scanfđọc năm dưới dạng một số nguyên trong y. Sau đó, y được điều chỉnh bằng 4 hoặc 400 tùy thuộc vào năm đó có chia hết cho 100 hay không. Nếu phần còn lại bằng 0, mã ASCII cho Y được gán cho y, nếu không, nó nhận được mã ASCII cho N. Giá trị của y bây giờ 0x000000??, đâu 0x??là nhân vật được chỉ định. Đang ở trên một máy tính nhỏ, trong bộ nhớ này được lưu trữ dưới dạng ?? 00 00 00. Đây là một chuỗi C kết thúc NULL, chỉ chứa các ký tự được gán. Địa chỉ của y được chuyển đến các vị trí và char được in (với một dòng mới).

PowerShell, 31 byte

Tôi rất phấn khích khi nói rằng tôi chơi golf này ngắn hơn so với nội dung!

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

Đầu ra đúng cho năm nhuận và sai khác.

Được xây dựng bên trong:

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

Mặc dù, nếu tôi muốn kéo dài câu lệnh 'nói rõ ràng với người dùng nếu đó là hoặc không phải là năm nhuận' và làm điều gì đó không chuẩn, tôi có thể lưu 3 byte và sử dụng:

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

Kết quả này 0cho các năm nhuận và 1 hoặc cao hơn cho các năm không nhuận, điều mà tôi không thích vì tôi muốn trả lại giá trị trung thực tiêu chuẩn hơn cho các năm nhuận.

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

Ung dung:

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

Trong Python không được chỉnh sửa, vì LOLCODE khó hiểu:

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