У мого вчителя Precalc є одна з його улюблених проблем, яку він склав (або, швидше за все, викрав натхненний xkcd ), що включає ряд nпісуарів. "Контрольний мат" - це ситуація, при якій кожен пісуар вже зайнятий АБО має зайнятий пісуар поруч. Наприклад, якщо людина є X, то

X-X--X

вважається мат. Зауважте, що людина не може зайняти пісуар поруч із вже зайнятим пісуаром.

Завдання

Ваша програма буде приймати число stdin, аргументи командного рядка або аргумент функції. Потім ваша програма роздруковує або повертає кількість способів, за якими може відбуватися реєстрація, із введеною кількістю піссуарів.

Приклади

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

Спробуйте в Інтернеті!

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

Після п’ятого елемента розрив у послідовності збільшується на п’ять попередніх.

Python 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 байти

Сильно натхненний оригінальною відповіддю 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. Якщо Trueйого можна використовувати для 1, нам не знадобляться 3 байти для +().

J, 31 27 23 байт

Збережено 4 байти завдяки милям!

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

Пояснення - незабаром.

Старе рішення

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

Це порядок денний. LHS - це дієслова, що складається з двох дієслів: >.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

Тут >.приймається максимум двох значень. Таким чином, він дає 1, 1 і 2 як початкові умови.

Другий дієслово в герунді - вилка:

-&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, де кожна можлива конфігурація є рядком. 1у цьому масиві представлена ​​зайнята позиція. Наприклад, для введення 4масив 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. Зайняті позиції та сусіди по зайнятих позиціях в А дають ненульовий результат у масиві B:

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

Отже, першою умовою для того, щоб конфігурація була мат - це те, що B не містить нулів у цьому рядку. Це означає, що в тому ряду А не було порожніх позицій, або були деякі, але були сусідами по зайнятих позиціях.

Нам потрібна друга умова. Наприклад, останній рядок відповідає вищевказаній умові, але не є частиною рішення, оскільки конфігурація не була дійсною для початку. Дійсна конфігурація не може мати двох сусідніх зайнятих позицій, тобто не може мати двох суміжних 1в А. В еквівалентному порядку, вона не може мати двох суміжних значень 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 байт

+3 для n=1; +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:

• перевірити двійковий п-значне уявлення для 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 байти

Відповідь Арнальда перенесено і гольф:

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.

JavaScript (ES6) / рекурсивний, 30 27 байт

Редагувати: збережено 3 байти завдяки Shaun H

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

JavaScript (ES6) / Нерекурсивний 90 77 байт

Редагувати: збережено 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));
}

Математика, 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використовує деяку магію цілого поділу.

Спробуйте в Інтернеті

Примітка: вихід може виглядати дивним, і це тому, що зазвичай використовується для виведення ймовірностей кісток. Просто подивіться на номер зліва від гістограми.

Perl, 35 34 байт

Включає +1 для -p

Введіть дані про STDIN

checkmate.pl <<< 8

checkmate.pl:

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

Нещодавно розроблена секретна формула. Ripple оновити 3 змінні стану без необхідності паралельних призначень.

Це однаково коротко (але набагато повільніше і займає набагато більше пам’яті), щоб просто вирішити початкову проблему:

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

але це не працює 0

JavaScript (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;

Необхідно, щоб вхід був присутній у стеку при запуску програми, тому +2 байти для -vпрапора. Спробуйте в Інтернеті!

Перший рядок ініціалізує стек до 1 1 2 n, де nномер введення. Другий рядок, який працює назад, перевіряє, що nбільший за 1. Якщо він є, 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. Однакова кількість байтів, що і PHP, хоча: D Пропозиції щодо гольфу вітаються.

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

Ungolfing

               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

Ungolfing

         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 байт

Це насправді порт "Денніса", більш довгий відповідь. Пропозиції з гольфу вітаються. Спробуйте в Інтернеті!

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

Ungolfing

         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.

Стакс , 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);}

Спробуйте в Інтернеті!

Haskell , 27 байт

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

Спробуйте в Інтернеті!