Benim Precalc öğretmen ayağa yapılan (veya daha büyük olasılıkla en sevdiği sorunlardan biri vardır çaldı esinlenerek XKCD bir sıra içermektedir) npisuar. "Şah mat" her pisuarın zaten meşgul olduğu veya YA yanlarında dolu bir pisuar bulunan bir durumdur. Örneğin, bir kişinin bir ise Xo zaman,

X-X--X

Şah mat olarak kabul edilir. Bir kişinin, zaten işgal edilmiş bir pisuarın yanında pisuar kullanamayacağını unutmayın.

Görev

Programınız stdinkomut satırı argümanları veya fonksiyon argümanları üzerinden bir sayı alacaktır . Ardından programınız, girilen pisuar sayısıyla birlikte kontrol arkadaşı oluşabileceği sayıların çıktısını alacaktır.

Örnekler

0 -> 1(boş durumda checkmate olarak sayılır)
1 -> 1( X)
2 -> 2( X-ya da -X)
3 -> 2( X-Xya da -X-)
4 -> 3( X-X-, -X-Xya da X--X)
5 -> 4( X-X-X, X--X-, -X-X-veya -X--X)
6 -> 5( X-X-X-, X--X-X, X-X--X, -X--X-ya da -X-X-X)
7 -> 7( X-X-X-X, X--X-X-, -X-X--X, -X--X-X, X-X--X-, X--X--Xya da -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-)
...

puanlama

Bayt cinsinden en küçük program kazanır.

Vaha , 5 bayt

kod

cd+2V

Genişletilmiş versiyon

cd+211

açıklama

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

Çevrimiçi deneyin!

Java 7, 65 42 bayt

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

Dizi sadece yenilerini almak için önceki unsurları ekler. Bu kısa yöntem için orlp ve Rod'a şapka ucu;)

Eski:

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

Beşinci elementten sonra, dizideki boşluk, önceki beş element tarafından artar.

Python 2, 42 40 39 35 bayt

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

Gerçek setlerin üretilmesi:

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")]

Ruby, 58 34 bayt

Geobits'in orijinal Java cevabından esinlenerek.

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

Repl.it üzerinde bakın: https://repl.it/Dedh/1

İlk girişim

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

Repl.it üzerinde bakın: https://repl.it/Dedh

Python, 33 bayt

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

Değiştirilen taban kasalarını kullanır f(-1) = f(0) = f(1) = 1. Eğer True1 için kullanılabilir, biz 3 bayt gerek olmazdı +().

J, 31 27 23 bayt

Mil sayesinde 4 bayt kurtarıldı!

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

Bir açıklama yakında gelecek.

Eski çözüm

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

Bu bir gündem. LHS iki fiilden oluşan bir fiildir: >.1&^ve -&3+&$:-&2. Birincisi, koşul ( 2&<) başarısız olursa kullanılır. Bu, çatalın >.1&^argüman üzerinden etkinleştirildiği anlamına gelir . Gözlemek:

   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

Burada, >.maksimum iki değer alır. Böylece, ilk terimler olarak 1, 1 ve 2 değerini verir.

Dergideki ikinci fiil bir çataldır:

-&3 +&$: -&2

Sol ve sağ dişler, sırasıyla 3 ve 2'yi çıkaran fiillere uygulanır; sonra orta fiil, bunlara eşit sol ve sağ argümanlarla çağrılır. $:her argümana fiili çağırır ve +bu ikisini ekler. Temelde eşdeğerdir($: arg - 3) + ($: arg - 2)

Test durumları

   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 bayt

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

Çevrimiçi deneyin! Veya tüm test durumlarını kontrol edin .

açıklama

İki toplantı! Yuppi!

Bu, olası her bir yapılandırmanın satır olduğu bir dizi oluşturur, A diyelim. 1Bu dizide işgal edilmiş bir konumu temsil eder. Örneğin, giriş 4için A dizisi

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

Kod daha sonra A dizini ile birlikte düzenler [1 1 1]. Bu, bir B dizisini verir. A'daki işgal edilmiş pozisyonlar ve işgal edilmiş pozisyonların komşuları, B dizisinde sıfır olmayan bir sonuç verir:

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

Bu nedenle, bir konfigürasyonun bir kontrol arkadaşı olması için ilk şart B'nin bu sırada sıfır içermemesidir. Bunun anlamı, A sırasındaki boş pozisyonların olmadığı veya bazılarının işgal edilmiş pozisyonların komşuları olduğu anlamına gelir.

İkinci bir koşula ihtiyacımız var. Örneğin, son satır yukarıdaki koşulu yerine getirir, ancak konfigürasyonun başlaması için geçerli olmadığı için çözümün bir parçası değildir. Geçerli bir yapılandırmada iki komşu işgal pozisyonu olamaz, yani 1A'da iki bitişik olamaz. Eşdeğer olarak B aşımında iki bitişik değere sahip olamaz 1. Böylece, B'yi kıvrılarak [1 1]ve sonuçtaki C dizisinde kontrol ederek bunu tespit edebiliriz.

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

bu satırdaki hiçbir değer aşılmaz 3. Nihai sonuç, iki koşulu yerine getiren yapılandırmaların sayısıdır.

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 bayt

+3 n=1; +9 $argv, -1-3 golf oynadı
-20: kombinasyonları yapmak zorunda olmadığımı fark ettim, ancak yalnızca sayıları

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

koşmak -r

2 ** n-1 ila 0 arasında bir döngü:

• için ikili n basamaklı gösterimini kontrol 11, 000, 00başında veya sonunda veya tek olarak0
• eşleşme yoksa sonucu arttır

sonucu yazdır

Aynı boyutta, biraz daha basit regex

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

• 2 ** n-1 ila 1 arasında döngü (0 yerine)
• için ikili gösterimini kontrol 11, 00başında veya sonunda veya000
• n = 0 için hiçbir şey yazdırmaz

PHP, 82 bayt

Arnauld’un cevabı taşındı ve golf oynadı:

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

n = 0 için hiçbir şey yazdırmaz

Jöle , 11 bayt

,’fR_2߀So1

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Nasıl çalışır

,’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) / Özyinelemeli, 30 27 bayt

Düzenleme: Shaun H sayesinde 3 bayt kaydedildi

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) / Özyinelemeyen 90 77 bayt

Düzenleme: Conor O'Brien ve Titus sayesinde 13 bayt kaydedildi

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 bayt

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

Bir fonksiyon tanımlar a. Girdi olarak bir tamsayı alır ve çıktı olarak bir tamsayı döndürür. Basit özyinelemeli çözüm.

AnyDice , 51 bayt

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

Buralarda daha fazla AnyDice cevabı olmalı.

Benim çözümüm hesaplayan özyinelemeli bir işlev tanımlar a(n)=a(n-2)+a(n-3). Bazı tamsayı bölme sihrini kullanarak döner a(0)=a(1)=1ve a(2)=2kullanır.

Çevrimiçi deneyin

Not: Çıktı tuhaf görünebilir ve bunun nedeni genellikle zar olasılığını ortaya çıkarmaktır. Sadece çubuk grafiğin solundaki sayıya bakın.

Perl, 35 34 bayt

İçin +1 içerir -p

STDIN'e giriş ver

checkmate.pl <<< 8

checkmate.pl:

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

Yeni geliştirilmiş bir gizli formül. Paralel atamalara gerek kalmadan dalgalanma güncelleme 3 durum değişkeni.

Sadece orjinal problemi çözmek aynı derecede kısadır (fakat çok daha yavaştır ve daha fazla hafıza alır).

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

ama bu işe yaramıyor 0

JavaScript (ES6), 62 bayt

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

İki kukla değişken adına ilk defa ihtiyacım vardı. Özyinelemeli bir sürüm muhtemelen daha kısa olacaktı, ama gerçekten sevdim reduce... Düzenleme: Sadece bir kukla değişkeni olan bir çözüm, ayrıca 62 bayt bulundu:

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

Jöle , 19 bayt

Özyinelemeli çözüm olduğunu muhtemelen daha kısa ...

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

Açıyla görün TryItOnline
Ya için dizi bakınız n = [0, 99]altındadır, TryItOnline

Nasıl?

n+3Kombinasyonları sayarak th Padovan'ın numarasını döndürür

Ḥ⁹_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 bayt

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

Girişte program başlangıcında yığında bulunması gerekir, bu nedenle -vbayrak için +2 bayt . Çevrimiçi deneyin!

İlk satır yığınının giriş numarasını 1 1 2 nnerede nolduğu ile başlatır . Geriye doğru koşan ikinci satır n1'den büyük olanı kontrol eder . Öyleyse n, azalır ve sıradaki bir sonraki eleman aşağıdaki gibi üretilir:

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

Son satır, dizideki gerekli öğe olan yığının altındaki sayıyı verir.

CJam , 20 bayt

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

Çevrimiçi deneyin!

açıklama

Bu, OEIS sayfasında gösterilen nüks ilişkisini kullanır .

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 bayt

XXXIGX@DŠ0@+

açıklama

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

Çevrimiçi deneyin!

FRACTRAN, 104 93 bayt

Giriş 11**n*29ve çıkış 29**checkmate(n).

Bu daha çok eğlenceliydi, çünkü şu anda Python, JS ve Java tarafından aşılmaya başladım . Yine de PHP ile aynı bayt sayısı: D Golf önerileri kabul edilir.

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

Aslında, 25 bayt

Bu basit bir f(n) = f(n-2) + f(n-3)nüks ilişkisi için biraz uzun görünüyor . Golf önerileri kabul edilir. Çevrimiçi deneyin!

╗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.

Aslında , 18 bayt

Bu aslında Dennis'in daha uzun Jelly cevabının limanı. Golf önerileri kabul edilir. Çevrimiçi deneyin!

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.

Stax , 7 bayt

ÉKΦΘÄO¢

Koş ve hata ayıkla

Yinelenme ilişkisini kullanır. C(n) = C(n-2) + C(n-3)

C (gcc) , 33 bayt

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

Çevrimiçi deneyin!

Haskell , 27 bayt

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

Çevrimiçi deneyin!