내 Precalc 교사는 그가 만들어 (또는 가능성이 그의 마음에 드는 문제 중 하나가 스톨 에 의해 영감을 XKCD 의 행 포함) n소변기를. "체크 메이트"는 모든 소변기가 이미 채워져 있거나 그 옆에 소변이 채워져있는 상황입니다. 예를 들어, 사람이 X인 경우

X-X--X

장군으로 간주됩니다. 이미 채워진 소변기 옆에있는 소변기를 점유 할 수는 없습니다.

태스크

프로그램은 stdin, 명령 줄 인수 또는 함수 인수를 통해 숫자를 가져 옵니다. 그러면 프로그램은 입력 된 소변기 수와 함께 checkmate가 발생할 수있는 방법을 인쇄하거나 반환합니다.

예

0 -> 1(널 케이스 장군으로 간주)
1 -> 1( X)
2 -> 2( X-또는 -X)
3 -> 2( X-X나 -X-)
4 -> 3( X-X-, -X-X, 또는 X--X)
5 -> 4( X-X-X, X--X-, -X-X-, 또는 -X--X)
6 -> 5( X-X-X-, X--X-X, X-X--X, -X--X-또는 -X-X-X)
7 -> 7( X-X-X-X, X--X-X-, -X-X--X, -X--X-X, X-X--X-, X--X--X또는 -X-X-X-)
8 -> 9( -X--X--X, -X--X-X-, -X-X--X-, -X-X-X-X, X--X--X-, X--X-X-X, X-X--X-X, X-X-X--X, X-X-X-X-)
...

채점

바이트 단위의 가장 작은 프로그램이 이깁니다.

오아시스 , 5 바이트

암호

cd+2V

확장 버전

cd+211

설명

1 = a(0)
1 = a(1)
2 = a(2)

a(n) = cd+
       c      # Calculate a(n - 2)
        d     # Calculate a(n - 3)
         +    # Add them up

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

자바 7, 65 42 바이트

int g(int u){return u>1?g(u-2)+g(u-3):1;}

시퀀스는 이전 요소를 추가하여 새로운 요소를 얻습니다. 이 짧은 방법을 위해 orlp와 Rod의 모자 팁;)

늙은:

int f(int u){return u<6?new int[]{1,1,2,2,3,4}[u]:f(u-1)+f(u-5);}

다섯 번째 요소 이후에는 시퀀스의 간격이 이전 요소 5만큼 증가합니다.

파이썬 2, 42 40 39 35 바이트

f=lambda n:n>1and f(n-2)+f(n-3)or 1

실제 세트 생성

lambda n:["{:0{}b}".format(i,n).replace("0","-").replace("1","X")for i in range(2**n)if"11"not in"{:0{}b}".format(i*2,2+n).replace("000","11")]

루비, 58 34 바이트

Geobits의 원래 Java 답변에서 크게 영감을 받았습니다.

f=->n{n<3?n:n<6?n-1:f[n-1]+f[n-5]}

repl.it에서 참조하십시오 : https://repl.it/Dedh/1

첫번째 시도

->n{(1...2**n).count{|i|!("%0#{n}b"%i)[/11|^00|000|00$/]}}

repl.it에서 참조하십시오 : https://repl.it/Dedh

파이썬, 33 바이트

f=lambda n:+(n<2)or f(n-2)+f(n-3)

이동 된 기본 사례를 사용합니다 f(-1) = f(0) = f(1) = 1. True1에 사용할 수 있으면에 3 바이트가 필요하지 않습니다 +().

J, 31 27 23 바이트

마일 덕분에 4 바이트를 절약했습니다!

0{]_&(]}.,+/@}:)1 1 2"_

설명은 곧 올 것이다.

오래된 솔루션

(>.1&^)`(-&3+&$:-&2)@.(2&<)

이것은 의제입니다. 좌변은 두 개의 동사로 구성된 동명사입니다 : >.1&^와 -&3+&$:-&2. 첫 번째 조건 ( 2&<)이 실패하면 사용됩니다 . 즉 >.1&^, 인수를 통해 포크 가 활성화됩니다. 관찰 :

   1 ^ 0 1 2
1 1 1
   (1&^) 0 1 2
1 1 1
   0 1 2 >. (1&^) 0 1 2
1 1 2
   (>.1&^) 0 1 2
1 1 2

여기서 >.최대 값은 2입니다. 따라서 초기 조건으로 1, 1 및 2가 생성됩니다.

gerund의 두 번째 동사는 포크입니다.

-&3 +&$: -&2

왼쪽과 오른쪽 타인이 동사에 적용되어 각각 3과 2를 뺍니다. 그런 다음 중간 동사는 왼쪽과 오른쪽의 인수와 동일하게 호출됩니다. $:각 인수에 대해 동사를 호출하고이 +두 개를 더합니다. 기본적으로($: arg - 3) + ($: arg - 2)

테스트 사례

   f =: (>.1&^)`(-&3+&$:-&2)@.(2&<)
   f 0
1
   f 2
2
   f 4
3
   f 6
5
   f 8
9
   F =: f"0         NB. for tables
   F i.13
1 1 2 2 3 4 5 7 9 12 16 21 28
   i.13
0 1 2 3 4 5 6 7 8 9 10 11 12
   (,. F) i.13
 0  1
 1  1
 2  2
 3  2
 4  3
 5  4
 6  5
 7  7
 8  9
 9 12
10 16
11 21
12 28

MATL , 25 23 바이트

W:qB7BZ+t!XAw3BZ+!3>a>s

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

두 개의 컨볼 루션! 예이!

그러면 가능한 각 구성이 행인 배열 A (예 : A)가 생성됩니다. 1이 배열에서 점유 된 위치를 나타냅니다. 예를 들어, 입력 4A의 경우 배열 A는

0 0 0 0
0 0 0 1
0 0 1 0
···
1 1 1 0
1 1 1 1

그런 다음 코드는 배열 A를로 변환 [1 1 1]합니다. 이것은 배열 B를 제공합니다. A에서 점유 된 위치와 점유 된 위치의 이웃은 배열 B에서 0이 아닌 결과를 제공합니다.

0 0 0 0
0 0 1 1
0 1 1 1
···
2 3 2 1
2 3 3 2

따라서 구성이 검사원이되기위한 첫 번째 조건은 B에 해당 행에 0이 포함되지 않는 것입니다. 이것은 A 행에 비어있는 위치가 없거나 점유 된 위치의 이웃이 있지만 일부가 있음을 의미합니다.

두 번째 조건이 필요합니다. 예를 들어, 마지막 행은 위의 조건을 충족하지만 구성이 처음부터 유효하지 않기 때문에 솔루션의 일부가 아닙니다. 유효한 구성은 두 개의 인접 점유 위치를 가질 수 없습니다. 즉 1A에서 두 개의 연속적인 위치를 가질 수 없습니다 . 마찬가지로, B에서 두 개의 연속 된 값을 초과 할 수 없습니다 1. 따라서 B를 축소 [1 1]하고 결과 배열 C에서이를 확인 하여이를 감지 할 수 있습니다 .

0 0 0 0
0 1 2 1
1 2 2 1
···
5 5 3 1
5 6 5 2

해당 행의 값이을 초과하지 않습니다 3. 최종 결과는 두 가지 조건을 충족하는 구성 수입니다.

W:q    % Range [0 1 ... n-1], where n is implicit input
B      % Convert to binary. Each number produces a row. This is array A
7B     % Push array [1 1 1] 
Z+     % 2D convolution, keeping size. Entries that are 1 or are horizontal 
       % neighbours of 1 produce a positive value. This is array B
t!     % Duplicate and transpose (rows become columns)
XA     % True for columns that contain no zeros
w      % Swap. Brings array B to top
3B     % Push array [1 1]
Z+     % 2D convolution, keeping size. Two horizontally contiguous entries
       % that exceed 1 will give a result exeeding 3. This is array C
!      % Transpose
3>     % Detect entries that exceed 3
a      % True for columns that contain at least one value that exceeds 3
>      % Element-wise greater-than comparison (logical and of first
       % condition and negated second condition)
s      % Sum (number of true values)

PHP, 105 (113) 93 바이트

n=1; +3 +9 $argv, -1-3 골프
-20 : 조합에 따를 필요는 없지만 그 개수 만 알았습니다.

for($i=1<<$n=$argv[1];$i--;)$r+=!preg_match("#11|(0|^)0[0,]#",sprintf("%0{$n}b,",$i));echo$r;

와 실행 -r

2 ** n-1에서 0으로 루프 :

• 이진 N 자리수의 표시를 확인 11, 000, 00시작 또는 끝에서 또는 단일0
• 일치하지 않으면 결과 증가

인쇄 결과

같은 크기, 약간 더 간단한 정규식

for($i=1<<$n=$argv[1];--$i;)$r+=!preg_match("#11|^00|00[,0]#",sprintf("%0{$n}b,",$i));echo$r;

• 2 ** n-1에서 1로 루프 (0 대신)
• 이진 표현을 확인 11, 00시작과 끝, 또는000
• n = 0에 대해서는 아무것도 인쇄하지 않습니다

PHP, 82 바이트

Arnauld의 답변은 포팅되고 골프를 쳤다 :

for($i=$k=1<<$n=$argv[1];--$i;)$r+=!($i&$x=$i/2|$i*2)&&(($i|$x)&~$k)==$k-1;echo$r;

n = 0에 대해서는 아무것도 인쇄하지 않습니다

젤리 , 11 바이트

,’fR_2߀So1

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

,’fR_2߀So1  Main link. Argument: n

 ’           Decrement; yield n - 1.
,            Pair; yield [n, n - 1].
   R         Range; yield [1, ..., n].
  f          Filter; keep the elements that are common to both lists.
             This yields [n, n - 1] if n > 1, [1] if n = 1, and [] if n < 1.
    _2       Subtract 2 from both elements, yielding [n - 2, n - 3], [-1], or [].
      ߀     Recursively call the main link for each integer in the list.
        S    Take the sum of the resulting return values.
         o1  Logical OR with 1; correct the result if n < 1.

자바 스크립트 (ES6) / 재귀, 30 27 바이트

편집 : Shaun H 덕분에 3 바이트 절약

let

f=n=>n<3?n||1:f(n-2)+f(n-3)

for(var n = 1; n < 16; n++) {
  console.log(n, f(n));
}

자바 스크립트 (ES6) / 비 재귀 90 77 바이트

편집 : Conor O'Brien 및 Titus 덕분에 13 바이트 절약

let f =

n=>[...Array(k=1<<n)].map((_,i)=>r+=!(i&(x=i>>1|i+i))&&((i|x)&~k)==k-1,r=0)|r

for(var n = 1; n < 16; n++) {
  console.log(n, f(n));
}

Mathematica, 35 바이트

a@0=a@1=1;a@2=2;a@b_:=a[b-2]+a[b-3]

함수를 정의합니다 a. 정수를 입력으로 취하고 정수를 출력으로 리턴합니다. 간단한 재귀 솔루션.

AnyDice , 51 바이트

function:A{ifA<3{result:(A+2)/2}result:[A-2]+[A-3]}

여기에 더 많은 AnyDice 답변이 있어야합니다.

내 솔루션은 계산하는 재귀 함수를 정의합니다 a(n)=a(n-2)+a(n-3). 정수 나누기 마술을 반환 a(0)=a(1)=1하고 a(2)=2사용합니다.

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

참고 : 출력이 이상하게 보일 수 있으며, 이는 일반적으로 주사위 확률을 출력하는 데 사용되기 때문입니다. 가로 막 대형 차트의 왼쪽에있는 숫자를보십시오.

펄, 35 34 바이트

에 +1 포함 -p

STDIN에 입력하십시오

checkmate.pl <<< 8

checkmate.pl:

#!/usr/bin/perl -p
$\+=$b-=$.-=$\-$b*4for(++$\)x$_}{

새로 개발 된 비밀 공식. 병렬 할당없이 3 개의 상태 변수를 리플 업데이트합니다.

원래 문제를 해결하는 것은 똑같이 짧습니다 (그러나 훨씬 느리고 메모리가 많이 걸립니다).

#!/usr/bin/perl -p
$_=grep!/XX|\B-\B/,glob"{X,-}"x$_

그러나 그것은 작동하지 않습니다 0

자바 스크립트 (ES6), 62 바이트

n=>[1,...Array(n)].reduce(($,_,i,a)=>a[i]=i<3?i:a[i-3]+a[i-2])

두 개의 더미 변수 이름이 필요한 것은 이번이 처음입니다. 재귀 버전은 아마도 더 짧을 것입니다.하지만 정말 좋아합니다 reduce... 편집 : 더미 변수가 하나 뿐인 62 바이트 솔루션도 발견했습니다.

n=>[1,...Array(n)].reduce((p,_,i,a)=>a[i]=i<5?i+2>>1:a[i-5]+p)

젤리 , 19 바이트

재귀 솔루션 은 아마도 더 짧을 것입니다 ...

Ḥ⁹_c@⁸
+3µ:2R0;瀵S

그것을 참조 TryItOnline
또는에 대한 일련의 볼 n = [0, 99]에 또한, TryItOnline

어떻게?

n+3조합을 계산하여 파도바의 수를 반환합니다

Ḥ⁹_c@⁸ - Link 1, binomial(k, n-2k): k, n
Ḥ      - double(2k)
 ⁹     - right argument (n)
  _    - subtract (n-2k)
     ⁸ - left argument (k)
   c@  - binomial with reversed operands (binomial(k, n-2k))

+3µ:2R0;瀵S - Main link: n
  µ       µ  - monadic chain separation
+3           - add 3 (n+3)
   :2        - integer divide by 2 ((n+3)//2)
     R       - range ([1,2,...,(n+3)//2]
      0;     - 0 concatenated with ([0,1,2,...,(n+3)//2]) - our ks
        ç€   - call previous link as a dyad for each
           S - sum

> <> , 25 + 2 = 27 바이트

211rv
v!?:<r@+@:$r-1
>rn;

프로그램 시작시 스택에 입력이 필요하므로 -v플래그에 +2 바이트가 필요합니다 . 온라인으로 사용해보십시오!

첫 번째 줄은 스택을 초기화합니다 . 1 1 2 n여기서 n입력 번호는입니다. 두 번째 줄은 거꾸로 실행하여 n1보다 큰지 확인합니다. 두 번째 줄 n은 줄이면 다음과 같이 시퀀스의 다음 요소가 생성됩니다.

r$:@+@r              a(n-3) a(n-2) a(n-1) n

r        Reverse   - n a(n-1) a(n-2) a(n-3)
 $       Swap      - n a(n-1) a(n-3) a(n-2)
  :      Duplicate - n a(n-1) a(n-3) a(n-2) a(n-2)
   @     Rotate 3  - n a(n-1) a(n-2) a(n-3) a(n-2)
    +    Add       - n a(n-1) a(n-2) a(n)
     @   Rotate 3  - n a(n) a(n-1) a(n-2)
      r  Reverse   - a(n-2) a(n-1) a(n) n

마지막 줄은 스택의 맨 아래에 번호를 출력하는데, 이는 시퀀스에서 필수 요소입니다.

CJam , 20 바이트

1_2_{2$2$+}ri*;;;o];

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

설명

이것은 OEIS 페이지에 표시된 반복 관계를 사용합니다 .

1_2_                   e# Push 1, 1, 2, 2 as initial values of the sequence
           ri          e# Read input
    {     }  *         e# Repeat block that many times
     2$2$              e# Copy the second and third elements from the top
         +             e# Add them
              ;;;      e# Discard the last three elements
                 o     e# Output
                  ];   e# Discard the rest to avoid implicit display

05AB1E , 12 바이트

XXXIGX@DŠ0@+

설명

XXX            # initialize stack as 1, 1, 1
   IG          # input-1 times do:
     X@        # get the item 2nd from bottom of the stack
       DŠ      # duplicate and push one copy down as 2nd item from bottom of the stack
         0@    # get the bottom item from the stack
           +   # add the top 2 items of the stack (previously bottom and 2nd from bottom)
               # implicitly print the top element of the stack after the loop

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

FRACTRAN, 104 93 바이트

입력 11**n*29및 출력은 29**checkmate(n)입니다.

특히 현재 Python, JS 및 Java에 의해 아웃 고프 (outgolfed)되어 있기 때문에 이것은 특히 재미있다 . PHP와 같은 바이트 수 : D Golf 제안은 환영합니다.

403/85 5/31 3/5 9061/87 3/41 37/3 667/74 37/23 7/37 38/91 7/19 5/77 1/7 1/17 1/2 340/121 1/11

언 골핑

               At the start we have 11**n * 29
1/11           If n < 2, we remove the 11s and print 29**1
340/121        If n >= 2, we subtract two 11s (n-2) and add one 17, two 2s and one 5.
                 We now have 17**1 * 29**1 * 2**2 * 5.
                 These are the register for a, b, c at registers 17, 29, and 2.
                 5 is an indicator to start the first loop.
                 This loop will move a to register 13.
403/85 5/31    Remove the 17s one at a time, adds them to the 13 register.
                 5 and 31 reset the loop.
3/5            Next loop: moves b to a and adds b to a in register 13.
9061/87 3/41   Remove the 29s one at a time, adds them to the 17 and 13 registers.
                 3 and 41 reset the loop.
37/3           Next loop: moves c to b in register 29.
667/74 37/23   Remove the 2s one at a time, adds them to the 29 register.
                 37 and 23 reset the loop.
7/37           Next loop: moves a+b to c in register 2.
38/91 7/19     Remove the 13s one at a time, adds them to the 2 register.
                 7 and 19 reset the loop.
5/77           Move to the first loop if and only if we have an 11 remaining.
1/7 1/17 1/2   Remove the 7 loop indicator, and all 17s and 2s.
               Return 29**checkmate(n).

실제로, 25 바이트

간단한 f(n) = f(n-2) + f(n-3)재발 관계에 대해서는 조금 길어 보입니다 . 골프 제안을 환영합니다. 온라인으로 사용해보십시오!

╗211╜¬`);(+)`nak╜2╜2<I@E

언 골핑

         Implicit input n.
╗        Save n to register 0.
211      Stack: 1, 1, 2. Call them a, b, c.
╜¬       Push n-2.
`...`n   Run the following function n-2 times.
  );       Rotate b to TOS and duplicate.
  (+       Rotate a to TOS and add to b.
  )        Rotate a+b to BOS. Stack: b, c, a+b
         End function.
ak       Invert the resulting stack and wrap it in a list. Stack: [b, c, a+b]
╜        Push n.
2        Push 2.
╜2<      Push 2 < n.
I        If 2<n, then 2, else n.
@E       Grab the (2 or n)th index of the stack list.
         Implicit return.

실제로 18 바이트

이것은 실제로 Dennis의 더 긴 젤리 답변 포트입니다. 골프 제안을 환영합니다. 온라인으로 사용해보십시오!

3+;╖½Lur⌠;τ╜-@█⌡MΣ

언 골핑

         Implicit input n.
3+       Add 3. For readibility, m = n+3.
;╖       Duplicate and store one copy of m in register 0.
½Lu      floor(m/2) + 1.
r        Range from 0 to (floor(m/2)+1), inclusive.
⌠...⌡M   Map the following function over the range. Variable k.
  ;        Duplicate k.
  τ╜-      Push m-2k. Stack: [m-2k, k]
  @█       Swap k and m-2k and take binomial (k, m-2k).
            If m-2k > k, █ returns 0, which does not affect the sum() that follows.
         End function.
Σ        Sum the list that results from the map.
         Implicit return.

Stax , 7 바이트

ÉKΦΘÄO¢

실행 및 디버깅

반복 관계를 사용합니다. C(n) = C(n-2) + C(n-3)

C (gcc) , 33 바이트

f(n){return n<2?1:f(n-2)+f(n-3);}

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

하스켈 , 27 바이트

r=1:1:2:zipWith(+)r(tail r)

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