Arka fon

Fibonacci döşemesi, (1D) çizgisinin iki segment kullanan bir döşemesidir: kısa bir, S ve uzun bir L, (uzunluk oranı altın orandır, ancak bu zorlukla ilgili değildir). Bu iki protokolü kullanan bir döşemenin aslında bir Fibonacci döşemesi olması için aşağıdaki koşulların yerine getirilmesi gerekir:

• Döşeme, SS alt dizisini içermemelidir .
• Döşeme, alt LLL içermemelidir .
• Aşağıdaki değişikliklerin tümünü gerçekleştirerek yeni bir döşeme oluşturulursa, sonuç yine de bir Fibonacci döşeme olmalıdır:
  1. LL → S
  2. S → L
  3. L → (boş dize)

Bazı örneklere bakalım:

SLLSLLSLLSLS

Bu geçerli bir döşeme gibi görünüyor, çünkü iki * S * veya üç * L * içermiyor, ancak kompozisyonu gerçekleştirelim:

LSLSLSLL

Bu hala iyi gözüküyor, ama bunu tekrar oluşturursak,

LLLS

ki bu geçerli bir Fibonacci döşemesi değildir. Bu nedenle, önceki iki dizi de geçerli eğimler değildi.

Öte yandan, eğer

LSLLSLSLLSLSLL

ve tekrar tekrar kısa dizilere

LSLLSLLS
LSLSL
LL
S

tüm sonuçlar geçerli Fibonacci eğimleridir, çünkü bu dizelerin içinde hiçbir zaman SS veya LLL elde edemeyiz .

Daha fazla okuma için, bu döşemeyi Penrose eğimlerine basit bir 1D benzetmesi olarak kullanan bir tez vardır.

Meydan okuma

Negatif olmayan bir tamsayı N verildiğinde , tüm geçerli Fibonacci döşemelerini N karakterleri ( Sveya L) içeren dizeler biçiminde döndüren bir program veya işlev yazın .

Girdi işlev argümanı STDIN veya ARGV aracılığıyla alınabilir ve sonucu döndürülebilir veya yazdırılabilir.

Bu kod golf, en kısa cevap (bayt cinsinden) kazanır.

Örnekler

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 bayt

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

STDIN'den okur. Çevrimiçi deneyin.

Örnek çalışma

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

Nasıl çalışır

Fikir, L ve S'nin tüm dizelerini uygun uzunlukta itmek, sonuç boş bir dize olana kadar her birine dönüşümü uygulamak, dizelerin dizilerini birleştirmek ve yasak alt dizeleri aramaktır.

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

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

Bu enflasyonist bir yaklaşımdır: bu başlar Lve Sve kuralları kullanarak genişletir LL -> SLS, L -> S, S -> LLve ön ya da arka Sbir olabilir Lkelime sınırında ilave edildi.

Çevrimiçi demo

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

Açıklama:

4 fonksiyon tanımlarım:

• f bir tamsayı alır ve sonucu döndürür

  replicateM n [L,S][L,S]uzunluğuyla olası tüm permütasyonları oluşturur n filter s ...bu listeyi (listelerin) işleviyle filtreleyecektirs

• r aa verilen listeyi 1 seviye azaltır.

  Bu sadece desen eşleştirme ile yapılır. 2 ile başlayan Lbir liste ile başlayan Sve azalan kalan bir liste haline gelecektir

• v verilen bir listeyi verilen kurallara göre doğrular (3 sürekli L, 2 sürekli S yok)

  liste yasadışı 2 diziden biriyle başlıyorsa (L, L, L veya S, S) sonuç şudur: Falseboş bir liste geçerlidir ve boş olmayan bir liste ilk eleman çıkarılmış olarak tekrar kontrol edilir

• s bir listenin ve tüm azaltılmış listelerin geçerli olup olmadığını kontrol eder.

  Tekrar: boş bir liste geçerlidir (ve daha fazla azaltılamaz).
  Bağımsız değişken olarak verilen liste geçerliyse, liste syeniden kontrol edilerek azaltılır .
  Aksi takdirde sonuçFalse