Lý lịch

Ốp lát Fibonacci là một lát gạch của dòng (1D) sử dụng hai phân đoạn: một đoạn ngắn, S và một đoạn dài, L (tỷ lệ chiều dài của chúng là tỷ lệ vàng, nhưng không liên quan đến thách thức này). Để ốp lát sử dụng hai prototile này để thực sự là một lát gạch Fibonacci, các điều kiện sau đây phải được đáp ứng:

• Ốp lát không được chứa SS sau đó .
• Ốp lát không được chứa LLL sau đó .
• Nếu một lát gạch mới được tạo bằng cách thực hiện tất cả các thay thế sau đây, kết quả vẫn phải là một lát gạch Fibonacci:
  1. LL → S
  2. S → L
  3. L → (chuỗi trống)

Hãy xem xét một số ví dụ:

SLLSLLSLLSLS

Điều này trông giống như một ốp lát hợp lệ, bởi vì nó không chứa hai * S * s hoặc ba * L * s nhưng hãy thực hiện bố cục:

LSLSLSLL

Điều đó vẫn có vẻ tốt, nhưng nếu chúng ta sáng tác lại, chúng ta sẽ nhận được

LLLS

đó không phải là một lát gạch Fibonacci hợp lệ. Do đó, hai chuỗi trước đó cũng không hợp lệ.

Mặt khác, nếu chúng ta bắt đầu với

LSLLSLSLLSLSLL

và liên tục soạn nó thành các chuỗi ngắn hơn

LSLLSLLS
LSLSL
LL
S

tất cả các kết quả là độ nghiêng Fibonacci hợp lệ, bởi vì chúng tôi không bao giờ có được SS hoặc LLL ở bất kỳ đâu trong các chuỗi đó.

Để đọc thêm, có một luận án sử dụng ốp này như một tương tự 1D đơn giản với nghiêng Penrose.

Các thách thức

Viết chương trình hoặc hàm, với một số nguyên N không âm , trả về tất cả các giá trị Fibonacci hợp lệ dưới dạng các chuỗi chứa N ký tự (đang Shoặc L).

Bạn có thể nhận đầu vào thông qua đối số chức năng, STDIN hoặc ARGV và trả lại hoặc in kết quả.

Đây là mã golf, câu trả lời ngắn nhất (tính bằng byte) sẽ thắng.

Ví dụ

N      Output
0      (an empty string)
1      S, L
2      SL, LS, LL
3      LSL, SLS, LLS, SLL
4      SLSL, SLLS, LSLS, LSLL, LLSL
5      LLSLL, LLSLS, LSLLS, LSLSL, SLLSL, SLSLL
...
8      LLSLLSLS, LLSLSLLS, LSLLSLLS, LSLLSLSL, LSLSLLSL, SLLSLLSL, SLLSLSLL, SLSLLSLL, SLSLLSLS

CJam, 70 62 59 byte

Qali{_'L:Xf+\'S:Yf++}*{{_X2*/Xf-Yf/Xf*Y*}h]N*_X3*#\Y2*#=},p

Đọc từ STDIN. Hãy thử trực tuyến.

Chạy ví dụ

$ cjam tilings.cjam <<< 5
["LLSLL" "SLSLL" "SLLSL" "LSLSL" "LSLLS" "LLSLS"]

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

Ý tưởng là đẩy tất cả các chuỗi L và S có độ dài phù hợp, lần lượt áp dụng phép biến đổi cho từng chuỗi cho đến khi kết quả là một chuỗi rỗng, nối các chuỗi của chuỗi và tìm kiếm các chuỗi bị cấm.

Qa         " Push R := [ '' ].                                                            ";
li{        " Do the following int(input()) times:                                         ";
  _'L:Xf+  " Append (X := 'L') to a copy of all strings in R.                             ";
  \'S:Yf+  " Append (Y := 'S') to all original strings in R.                              ";
  +        " Concatenate the arrays into R.                                               ";
}*         " R now contains all strings of L's and S's of length int(input()).            ";
{          " For each S ∊ R:                                                              ";
  {        "                                                                              ";
    _      " Push a copy of S.                                                            ";
    X2*/   " Split S at 'LL'.                                                             ";
    Xf-    " Remove 'L' from the chunks.                                                  ";
    Yf/    " Split the chunks at 'S'.                                                     ";
    Xf*    " Join the chunks, separating by 'L'.                                          ";
    Y*     " Join, separating by 'S'.                                                     ";
  }h       " If the resulting string is non-empty, repeat.                                ";
  ]N*      " Join the array of resulting strings from S to '', separating by linefeeds.   ";
  _X3*#    " Push the index of 'LLL' a copy in the resulting string (-1 if not present).  ";
  \Y2*#    " Push the index of 'SS' in the original string (-1 if not present).           ";
  =        " Check if the indexes are equal; this happens if and only if both are -1.     ";
},         " Filter: Keep S in R if and only if = pushed 1.                               ";
p          " Print a string representation of R.                                          ";

GolfScript (86 byte)

~:|'LS'1/\{{.{1&!'LLS'2/=}%'SS'/'SLS'*[.(1&{'LS'\+}*]{.)1&{'SL'+}*}/}%.&}*['']+{,|=},p

Đây là một cách tiếp cận lạm phát: nó bắt đầu với Lvà Svà mở rộng chúng bằng cách sử dụng quy tắc LL -> SLS, L -> S, S -> LL, và ở đầu hoặc cuối Scó thể có một Lbổ sung ở ranh giới từ.

Bản demo trực tuyến

Haskell, 217

import Control.Monad
data F=L|S deriving (Eq)
f n=filter s$replicateM n [L,S]
r (L:L:m)=S:r m
r (S:m)=L:r m
r (L:m)=r m
r []=[]
s []=True
s m|v m=s$r m
s _=False
v (L:L:L:_)=False
v (S:S:_)=False
v (_:m)=v m
v []=True

Giải thích:

Tôi xác định 4 chức năng:

• f lấy một số nguyên và trả về kết quả

  replicateM n [L,S]tạo tất cả các hoán vị có thể có [L,S]với độ dài n filter s ...sẽ lọc danh sách này (của danh sách) với chức năngs

• r giảm aa danh sách cho trước 1 cấp.

  Điều này được thực hiện đơn giản bằng cách khớp mẫu. Một danh sách bắt đầu bằng 2 Lsẽ trở thành một danh sách bắt đầu bằng Svà phần còn lại giảm

• v xác nhận một danh sách nhất định theo các quy tắc đã cho (không có 3 L liên tục, không có 2 liên tục S)

  nếu danh sách bắt đầu bằng một trong 2 chuỗi bất hợp pháp (L, L, L hoặc S, S) thì kết quả là Falsemột danh sách trống và danh sách không trống được kiểm tra lại với phần tử đầu tiên bị xóa

• s kiểm tra nếu một danh sách và tất cả các danh sách giảm là hợp lệ.

  Xin nhắc lại: một danh sách trống là hợp lệ (và không thể giảm thêm nữa).
  Nếu danh sách được cung cấp dưới dạng đối số là hợp lệ thì danh sách bị giảm quảng cáo được kiểm tra slại.
  Nếu không thì kết quả làFalse