sfondo

La piastrellatura di Fibonacci è una piastrellatura della linea (1D) che utilizza due segmenti: uno corto, S e lungo, L (il loro rapporto di lunghezza è il rapporto aureo, ma non è rilevante per questa sfida). Affinché una piastrellatura che utilizza questi due prototipi sia in realtà una piastrellatura di Fibonacci, devono essere soddisfatte le seguenti condizioni:

• La piastrellatura non deve contenere la sottosequenza SS .
• La piastrellatura non deve contenere la sottosequenza LLL .
• Se una nuova piastrellatura è composta eseguendo tutte le seguenti sostituzioni, il risultato deve essere ancora una piastrellatura di Fibonacci:
  1. LL → S
  2. S → L
  3. L → (stringa vuota)

Diamo un'occhiata ad alcuni esempi:

SLLSLLSLLSLS

Sembra una piastrellatura valida, perché non contiene due * S * se tre * L * ma eseguiamo la composizione:

LSLSLSLL

Sembra ancora bene, ma se lo componiamo di nuovo, otteniamo

LLLS

che non è una piastrellatura di Fibonacci valida. Pertanto, le due sequenze precedenti non erano neppure valori validi.

D'altra parte, se iniziamo con

LSLLSLSLLSLSLL

e comporre ripetutamente questo in sequenze più brevi

LSLLSLLS
LSLSL
LL
S

tutti i risultati sono limiti di Fibonacci validi, perché non otteniamo mai SS o LLL da nessuna parte all'interno di quelle stringhe.

Per ulteriori letture, esiste una tesi che utilizza questa piastrellatura come una semplice analogia 1D con i tasselli di Penrose.

La sfida

Scrivi un programma o una funzione che, dato un numero intero non negativo N , restituisce tutte le piastrellature di Fibonacci valide sotto forma di stringhe contenenti N caratteri (essere So L).

È possibile accettare input tramite argomento di funzione, STDIN o ARGV e restituire o stampare il risultato.

Questo è il codice golf, vince la risposta più breve (in byte).

Esempi

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

Legge da STDIN. Provalo online.

Esempio di esecuzione

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

Come funziona

L'idea è di spingere tutte le stringhe di L e S della lunghezza corretta, applicare successivamente la trasformazione a ciascuna fino a quando il risultato non è una stringa vuota, concatenare le sequenze di stringhe e cercare le sottostringhe proibite.

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

Questo è un approccio inflazionistica: si inizia con Le Se li espande utilizzando le regole LL -> SLS, L -> S, S -> LL, e iniziale o finale Spuò avere un Laggiunta al limite di parola.

Demo online

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

spiegazione:

Definisco 4 funzioni:

• f accetta un numero intero e restituisce il risultato

  replicateM n [L,S]crea tutte le possibili permutazioni di [L,S]con la lunghezza n filter s ...filtrerà questo elenco (di elenchi) con la funziones

• r riduce un dato elenco di 1 livello.

  Questo è semplicemente fatto dalla corrispondenza del modello. Un elenco che inizia con 2 Ldiventerà un elenco che inizia con Se il rimanente ridotto

• v convalida un determinato elenco in base alle regole fornite (n. 3 L continue, n. 2 S continue)

  se l'elenco inizia con una delle 2 sequenze illegali (L, L, L o S, S) il risultato è False, un elenco vuoto è valido e un elenco non vuoto viene ricontrollato con il primo elemento rimosso

• s controlla se un elenco e tutti gli elenchi ridotti sono validi.

  Ancora: un elenco vuoto è valido (e non può essere ulteriormente ridotto).
  Se l'elenco indicato come argomento è valido, l'elenco viene ridotto e ricontrollato s.
  Altrimenti il ​​risultato èFalse