이 도전은 매우 간단합니다. 1801 년에서 2400 년 사이의 연도를 입력하고 윤년인지 여부를 출력합니다.

입력 내용에는 줄 바꿈 또는 후행 공백이 없습니다.

1954

윤년인지 아닌지를 명확하게 알려주는 방식으로 원하는 방식으로 출력합니다 (예 / 아니오로 y 또는 n을 수락합니다)

당신은 여기에서 윤년 목록을 얻을 수 있습니다 : http://kalender-365.de/leap-years.php 윤년이 항상 4 년은 아니라는 것을 알고 싶습니다. 1896 년은 윤년이지만 1900 년은 아닙니다. 이 "건너 뛰기"를 따르는 년은 다음과 같습니다.

1900
2100
2200
2300

테스트 사례 :

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

편집 : 이것은 표준 그레고리력 달력을 기반으로합니다 : http://www.epochconverter.com/date-and-time/daynumbers-by-year.php

APL, 16 14 12 자

0윤년 1이 아닌 윤년을 반환 합니다 .

≥/⌽×4 25 4⊤⎕

tryapl.org 에서이 솔루션을 사용해보십시오 . {≥/⌽×4 25 4⊤⍵}tryapl.com이 지원하지 않기 때문에 솔루션을 dfn 으로 변경했습니다 ⎕. 참고 ⎕빈 상자가 아닌 누락 된 문자입니다.

J의 동일한 솔루션 :

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

설명

Dyadic ⊤(인코딩)은 왼쪽 인수로 지정된 기본에서 오른쪽 인수를 나타냅니다. 4 25 4이 솔루션에서 기본 을 사용 합니다. 이것은 y 를 다항식으로 나타냅니다

y mod 400 = 100 a + 4 b + c  여기서 b <100 및 c <4입니다.

명제하자 , β를 α, 및 γ 경우 나타내는 A, B, 및 C가 비 제로인 : 법안 γ 거짓이 경우 , Y가 (4)에 의해 분할 가능하고, β ∧ γ는 경우 거짓 Y가 100에 의해 분할 가능하다 α ∧ β ∧ γ IS y 를 400으로 나눌 수 있으면 false 입니다.

진리표 ( *"무관심"을 나타냄)는 제안이 Δ y 가 윤년을 얻는 경우를 나타냅니다 .

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

다음 문장은 α , β 및 γ 에서 Δ를 표현합니다 .

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

이 진술의 구조로 인해 ≥/⌽α β γ, ≥가 ←를 구현 하는 축소 로 ¬Δ를 표현할 수 있습니다 . 이것은 내가 지금 설명하는 대답으로 이어집니다.

Pyth, 11 바이트

!%|F_jQ*TT4

이 전체 프로그램은 STDIN에서 읽고 윤년 동안 True 를 인쇄 하고 그렇지 않으면 False 를 인쇄합니다 .

Pyth를 제안하고 기본적으로 CJam 코드를 포팅 한 @Jakube에게 감사드립니다.

Pyth Compiler / Executor 에서 테스트 사례를 직접 확인하십시오 .

작동 원리

     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 바이트

rS+2m<~e|4%!

이 전체 프로그램은 STDIN에서 읽고 윤년 동안 1을, 그렇지 않으면 0을 인쇄합니다.

CJam 인터프리터 에서 테스트 사례를 직접 확인하십시오 .

작동 원리

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.

자바 스크립트 (ES6), 21 자

표준 규칙은 y4를 나누고 y100을 나누지 y않거나 400을 나누면 윤년 y입니다. 코드에서

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

100과 400이 필요하지 않습니다. 대신 16 또는 4가 y를 나누는 지 여부를 확인하면 충분하고, 25가 y를 나누면 16을, 그렇지 않으면 4를 선택합니다. 골프, 이것은

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

이를 구현하는 자바 스크립트 함수의 길이는 21 자입니다.

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

펄, 28 26 자

같은 생각이지만 펄입니다.

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

-lp옵션을 사용하여 실행하십시오 . 예를 들어

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

테스트 세트를 입력으로 설정하면

1936
y
1805
n
1900
n
2272
y
2400
y

핍 , 13 바이트

이것은 처음 등장한 것보다 더 흥미로웠다. 그것은 몇 가지 finagling을했다,하지만 난 결국에 그 긴 참조 대체 할 수 있었다 400로 4하고 h변수 (= 100).

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

1윤년 0이 아닌 윤년에 대한 출력 . 설명:

               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 바이트

xFm!%Q^d2[2TyT

너무 쉬운 방법입니다. 온라인으로 사용해보십시오 : 데모 또는 테스트 장치

편집 : 누락, 대신 Truthy / Falsy 값을 인쇄 할 수 있습니다 n/y. -4 바이트

편집 2 : 마틴의 제곱근 아이디어를 사용했습니다. -1 바이트

설명

                 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

정규식, 83 62 38

정규식의 두 절반을 결합하는 방법에 대한 팁을 제공 한 Toby에게 감사합니다.

1801..2400 범위에만 집중하고 입력이 정수라고 가정하면 :

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

원하는 범위에 대해 Ruby 에서 테스트하십시오 ( ^= \A및 $= \ZRuby이므로).

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) 1801..2400뿐만 아니라 음수가 아닌 연도에 효과가있는 것 :

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

처음 100000 년 동안 Ruby 에서 테스트 ( ^= \A및 $= \ZRuby이므로) :

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

자바 스크립트 ( ES6 ) 27

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

골프 : !(y%100<1&&y%400||y%4)(주로 데모 간 법칙 사용 )

규칙을 구현하는 함수 :

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

다음을 확인하기위한 테스트 (Firefox에서 실행) :

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

TI-BASIC은 토큰 화되어 있기 때문에 간단한 수학 문제에서 경쟁이 치열하지만 "분할"명령이 없기 때문에이 문제는 아닙니다. 어쩌면 결국 CJam과 Pyth보다 더 깁니다.

이것은 David Hammond의 방법을 사용합니다.

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

16 바이트의 이전 코드 :

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

언 골프 드 :

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

fPart("분획 부분"이고; 지수는 나누기보다 우선 순위가 높습니다. TI-BASIC에서는 클로즈 패런이 옵션입니다.

문서화되지 않은 sub(명령의 동작을 사용하며 일반적으로 하위 문자열을 얻는 데 사용됩니다. 인수가 문자열 대신 숫자 인 경우 숫자를 100으로 나눕니다. TI-83 또는 84 시리즈 계산기에서 작동합니다.

근접 파렌을 제거 할 수 있도록 코드를 재 배열함으로써 20-> 17; 400을 16으로 대체하여 17-> 16; 16-> 13 David Hammond의 아이디어를 사용하여.

Stackylogic, 226 바이트 (비경쟁)

그래 맞아. Helka Homba가 발명 한 Stackylogic (비 TC)에서 프로그램을 만들었 습니다 . 이것은 도전 후에 이루어 지므로 경쟁이 아닙니다.

Stackylogic에는 이진 입력 만 있으므로 10 (또는 더 많은 숫자는 무시 됨) 비트 이진을 사용해야합니다 (먼저 중요한 비트가 가장 먼저 입력 됨). 입력 된 숫자가 무엇인지 간단히 확인하기 때문에 지정된 범위를 벗어난 날짜는 실패 할 수 있습니다. 불필요한 날짜는 포함하지 않습니다.

이것이 stackylogic의 첫 번째 도전 일뿐만 아니라 stackylogic의 첫 번째 도전입니다.

이 혼란에 대비하십시오 :

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

Stackylogic이 가장 혼란스럽고 읽을 수없는 언어이기 때문에 시간이 너무 오래 걸렸습니다. 편집중인 현재 섹션을 읽으려면 프로그램의 나머지 부분이 어떻게 실행되었는지 알아야합니다. 가독성을 위해 공백을 추가해야했습니다.

빈약 한 설명

이것이하는 일에 대한 간단한 설명입니다.

Stackylogic에는 수학 함수가 없으므로이를 어렵게 만들었습니다. 특정 숫자인지 확인하기 위해 대부분의 하드 코드를 작성해야했습니다.

먼저,이 프로그램은 최하위 비트의 NOR을 수행하여 프로세스에서 버립니다. 즉, 4로 나눌 수 있으면 프로그램의 주요 부분으로 진행하고 그렇지 않으면 0을 출력합니다.

둘째, 포인터는 stackylogic의 미로로 옮겨집니다. 여기에서 다음 두 비트가 0이면 즉시 1을 출력합니다 (그러면 다른 조건에도 불구하고 16으로 나눌 수 있으므로 윤년) 현명하게도 1801과 2400 사이에서 4로 나눌 수 있지만 윤년이 아닌 숫자가 아닌지 확인합니다.

자세하게 설명하려면이 게시물을 기존보다 몇 배 더 길게 만들어야합니다.

IBM System Z 어셈블러-56 바이트

(소스의 96 바이트. 이전 712 384 원 202 바이트, 168 바이트의 실행).

더 작은 버전입니다. 더 이상 발신자의 레지스터, 리터럴 스토리지 변경, 주소 지정 모드 변경을 저장하지 않습니다.

 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 

새로운 버전. 윤년이면 S0C1과 함께 종료되고 그렇지 않으면 루프됩니다. 바라건대 결과 표시의 요구 사항을 충족시킵니다.

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, 그래서 가장 짧지는 않습니다 (실제로 실행 된 코드에 인터프리터 크기를 더한 것이 보일 수도 있지만 ...)

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  

산출:

윤년 동안 S0C1을 종료하고, 그렇지 않으면 S222 (CPU 시간이 만료 된 경우).

1936 년 1805 년 1900 년 N 2272 년 2400 년 Y

(여러 번 실행할 때)

CJam, 18 16 바이트

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

부여 1윤년과 대한 (truthy) 0그렇지 않으면 (falsy을).

여기에서 모든 테스트 사례를 실행하십시오.

설명

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 바이트, 17 자

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

17 개의 문자를 사용하지만 27 바이트를 사용합니다. 팁을위한 @alephalpha에게 감사합니다. 수직 막대는 실제로 나누기의 U + 2223입니다. 는 <U+F523>해당 문자로 대체한다.

R, 29

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

시운전

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

더 짧게 할 수는 있지만 인수를 구문 분석하지 않고 'char'유형을 깔끔하게 고수합니다 (예 :) atoi.

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

인수가 NUL로 구분 된 프로그램 이름 바로 뒤에 오는 표준 가정을 만들기 때문에 이름은 4 자 길이로 호출해야합니다. 또한 단일 인수가 ASCII로 인코딩되고 선행 공백이 없다고 가정합니다.

설명:

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의 '자리수'자리의 위치입니다 v[1]+2.

'tens'와 'units'문자가 96에 더 해지면 우리는로 끝나고 00, 따라서 'tens'와 'units'는 세기 숫자를 가리 키도록 두 문자를 백업합니다.

이제 xor 'units'는 'tens'의 두 배, mod 4입니다. 이것은 'tens' 10==±2 mod 4의 하위 비트가 'units'의 비트 1을 토글 할 수 있기 때문에 작동합니다 . 결과를 나머지 테이블에 대한 인덱스로 사용하여 y모듈 식 결과가 0 인 경우에만 인쇄 합니다.

Befunge -98, (41 바이트)

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

단순함이 대단합니다.

sed, 55

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

• 첫 줄은 정확한 세기를 100으로 나눕니다.
• 두 번째 줄은 홀수 자릿수에 'N', 'y'~ 4s, 'n'에 4가 아닌 숫자를 제공합니다.
• 두 번째 홀수가 두 번째 홀수 인 경우 세 번째 줄은 'y'와 'n'을 바꿉니다 (10이 2 mod 4이므로)
• 마지막 줄은 마지막 문자를 제외한 모든 문자를 삭제합니다

비 윤년과 같이 인쇄 할 수 있습니다 n또는 N그들이 짝수 또는 홀수인지에 따라. 나는 이것을 규칙의 창조적 해석으로 간주하여 대안이 일관성이 있어야한다는 것을 지정하지 않고 '예'와 '아니오'를 대체 할 수 있습니다.

파이썬 2-37

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

a음수가 아닌 정수인 경우 a<1쓰는 간단한 방법입니다 not bool(a). 따라서 마지막 <1은 괄호 안의 표현식을 부울로 효과적으로 변환하고 결과를 무효화합니다.

윤년 인 경우 에는 1801에서 2400 사이 g의 정수에 함수 를 적용하면 그렇지 않으면 반환됩니다.nTruenFalse

KDB (Q), 27 바이트

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

설명

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

테스트

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

줄리아, 30 28 바이트

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

정수 인수를 허용하고 부울 값을 리턴하는 이름없는 함수를 작성합니다. 호출하려면 이름을 지정하십시오 (예 :) f=y->....

언 골프 드 :

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

예:

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

PHP-45 바이트

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

정말 특별한 것은 없습니다. 단지 유형 저글링을 학대하는 것입니다.

C #, 23 바이트

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

온라인으로 사용해보십시오!

테스트 사례를 포함한 전체 소스 :

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 바이트

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

완드 박스

T-SQL 37 22 바이트

BradC의 의견으로 15 바이트를 절약했습니다.

가없는 일반적인 하드 코딩 된 변수입니다 stdin.

예 :

DECLARE @ NVARCHAR(4) = '2016'

그런 다음 해결책은 다음과 같습니다.

PRINT ISDATE(@+'0229')

자바 8, 49 45 22 20 바이트

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

@ OlivierGrégoire 덕분에 -2 바이트 .

온라인으로 사용해보십시오.

일부 22 바이트 솔루션 :

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

온라인으로 사용해보십시오.

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

온라인으로 사용해보십시오.

java.time.Year::isLeap

온라인으로 사용해보십시오.

설명:

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

하스켈, 19 바이트

f i=gcd 80i>gcd 50i

온라인으로 사용해보십시오!

자바 스크립트 ES6, 32, 29, 26

다음 라인 중 하나가 작동합니다.

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 바이트

후행 공백 / 개행 문자 유무에 관계없이 stdin에서 입력을 가져옵니다. 리틀 엔디 언 머신에서만 작동합니다 (예, 모든 사람들이 요즘 BE에있는 것처럼). Y 또는 N을 출력합니다.

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

설명

언 골프 드 :

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

먼저 scanf연도를 y의 정수로 읽습니다. 그런 다음 연도를 100으로 나눌 수 있는지 여부에 따라 y는 4 또는 400으로 모듈화됩니다. 나머지가 0이면 Y에 대한 ASCII 코드가 y에 할당되고, 그렇지 않으면 N에 대한 ASCII 코드를 가져옵니다. y의 값 is now 0x000000??, 0x??할당 된 문자는 어디 입니까? 리틀 엔디안 머신에 있기 때문에 메모리에 이것은로 저장됩니다 ?? 00 00 00. 지정된 문자 만 포함하는 NULL로 끝나는 C 문자열입니다. y의 주소가 풋으로 전달되고 문자가 후행 줄 바꿈과 함께 인쇄됩니다.

PowerShell, 31 바이트

나는 이것이 내장보다 짧은 골프를했다는 것을 기쁘게 생각합니다!

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

윤년에는 true를, 그렇지 않으면 false를 출력합니다.

내장 :

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

비록 '도약 년인지 아닌지 명확하게 사용자에게 말하고'표준을 비표준으로 만들고 싶다면 3 바이트를 절약하고 다음을 사용할 수 있습니다.

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

이것은 0윤년 동안 출력 하고 비 윤년 동안 1 이상을 출력 합니다.

LOLCODE, 228 (202) 159 바이트

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

언 골프 드 :

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

LOLCODE가 혼란 스럽기 때문에 파이썬에서는 ungolfed입니다.

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