वैध फाइबोनैचि झुकाव उत्पन्न करें

Question

पृष्ठभूमि

फाइबोनैचि टाइलिंग दो खंडों का उपयोग करके (1D) लाइन की एक टाइलिंग है: एक छोटा, S और एक लंबा, L (उनकी लंबाई का अनुपात स्वर्णिम अनुपात है, लेकिन यह इस चुनौती के लिए प्रासंगिक नहीं है)। इन दो प्रोटोटाइल्स का उपयोग करके वास्तव में एक फिबोनाची टाइलिंग करने के लिए, निम्नलिखित शर्तों को पूरा करना होगा:

• टाइलिंग में बाद का एसएस शामिल नहीं होना चाहिए ।
• टाइलिंग में एलएलएल नहीं होना चाहिए ।
• यदि निम्नलिखित सभी बारीकियों को पूरा करते हुए एक नया टाइलिंग बनाया जाता है, तो परिणाम अभी भी एक फिबोनाची टाइलिंग होना चाहिए:
  1. एलएल → एस
  2. एस → एल
  3. एल → (खाली स्ट्रिंग)

आइए कुछ उदाहरण देखें:

SLLSLLSLLSLS

यह एक मान्य टाइलिंग की तरह दिखता है, क्योंकि इसमें दो * S * s या तीन * L * s शामिल नहीं हैं, लेकिन चलो रचना करते हैं:

LSLSLSLL

यह अभी भी ठीक लग रहा है, लेकिन अगर हम इसे फिर से बनाते हैं, तो हम प्राप्त करते हैं

LLLS

जो एक वैध फाइबोनैचि टाइलिंग नहीं है। इसलिए, पिछले दो अनुक्रम या तो मान्य झुकाव नहीं थे।

दूसरी ओर, अगर हम शुरुआत करते हैं

LSLLSLSLLSLSLL

और बार-बार इसे छोटे दृश्यों के लिए लिखें

LSLLSLLS
LSLSL
LL
S

सभी परिणाम वैध फाइबोनैचि झुकाव हैं, क्योंकि हम उन तारों के अंदर कहीं भी एसएस या एलएलएल प्राप्त नहीं करते हैं।

आगे पढ़ने के लिए, एक थीसिस है जो इस टाइलिंग को पेनड्रिल टिलिंग्स के लिए एक सरल 1D सादृश्य के रूप में उपयोग करता है।

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें, जो एक गैर-नकारात्मक पूर्णांक एन दिया गया है , एन अक्षर (होने Sया होने L) वाले स्ट्रिंग्स के रूप में सभी वैध फाइबोनैचि टाइलिंग लौटाता है ।

आप फ़ंक्शन तर्क, STDIN या ARGV के माध्यम से इनपुट ले सकते हैं और परिणाम को प्रिंट या प्रिंट कर सकते हैं।

यह कोड गोल्फ है, सबसे छोटा उत्तर (बाइट्स में) जीतता है।

उदाहरण

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

Comments

कि होना चाहिए LSLSL-> LL?

@ टोलोस आह हां, अच्छा कैच। मैंने तय किया कि FYI करें, ऐसा इसलिए हुआ क्योंकि मैंने वास्तव में इसी तरह के अपघटन नियमों का उपयोग करके नीचे से शुरू करते हुए स्ट्रिंग को दूसरे तरीके से उत्पन्न किया था, और जब यह टुकड़े की सीमाओं की बात आती है, तो बिल्कुल उल्टा नहीं होता है।

— मार्टिन एंडर

Answer 1

CJam, 70 62 59 बाइट्स

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

STDIN से पढ़ता है। इसे ऑनलाइन आज़माएं।

उदाहरण चलाते हैं

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

यह काम किस प्रकार करता है

विचार उचित लंबाई के एल और एस के सभी तारों को धकेलना है, क्रमिक रूप से प्रत्येक में परिवर्तन लागू करना है जब तक कि परिणाम एक रिक्त स्ट्रिंग नहीं है, स्ट्रिंग्स के अनुक्रमों को संक्षिप्त करें और निषिद्ध सब्सट्रेटिंग की खोज करें।

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.                                          ";

Answer 2

गोल्फस्क्रिप्ट (86 बाइट्स)

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

यह एक मुद्रास्फीति दृष्टिकोण है: यह साथ शुरू होता है Lऔर Sऔर नियमों का उपयोग कर उन्हें फैलता है LL -> SLS, L -> S, S -> LL, और आगे या पीछे Sएक हो सकता है Lशब्द सीमा पर गयी।

ऑनलाइन डेमो

Comments

@ मार्टिनबटनर, मैं आम तौर पर एक ऑनलाइन डेमो को golfscript.apphb.com के साथ जोड़ता हूं, लेकिन यह नेस्टेड लूप्स के आसपास बग के साथ एक पुराना संस्करण चला रहा है ( 3 दिसंबर 2012 रिलीज में तय ) और इस कार्यक्रम को सही ढंग से निष्पादित नहीं कर सकता है।

— पीटर टेलर

@ मार्टिनबटनर ऊप्स। मुझे बग के बारे में बताने के लिए धन्यवाद दोस्तों। मैंने नए जीएस संस्करण के साथ वेबसाइट को अपडेट किया। डेमो के लिए इस लिंक पर क्लिक करें ।

— क्रिस्टियन लुपस्कू

@ w0lf, अद्यतन के लिए धन्यवाद (और हाल की परिवर्तन के लिए समय सीमा को भी बढ़ाने के लिए)।

— पीटर टेलर

Answer 3

हास्केल, 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

explaination:

मैं 4 कार्यों को परिभाषित करता हूं:

• f पूर्णांक लेता है और परिणाम देता है

  replicateM n [L,S][L,S]लंबाई के साथ सभी संभावित क्रमपरिवर्तन बनाता है n filter s ...जो फ़ंक्शन के साथ इस सूची (सूचियों) को फ़िल्टर करेगाs

• r 1 स्तर द्वारा आ दी गई सूची को कम करता है।

  यह बस पैटर्न मिलान द्वारा किया जाता है। 2 के साथ शुरू होने वाली एक सूची एक सूची Lबन जाएगी जिसके साथ शुरुआत होगी Sऔर शेष शेष

• v दिए गए नियमों द्वारा दी गई सूची को मान्य करता है (कोई 3 निरंतर एल, कोई 2 निरंतर एस)

  यदि सूची 2 अवैध अनुक्रमों (L, L, L या S, S) में से किसी एक के साथ शुरू होती है False, तो परिणाम एक खाली सूची मान्य है, और एक गैर-रिक्त सूची को पहले हटाए गए तत्व के साथ फिर से जांचा जाता है।

• s जाँच करता है कि क्या सूची और सभी कम की गई सूचियाँ मान्य हैं।

  फिर से: एक खाली सूची मान्य है (और इसे और कम नहीं किया जा सकता है)।
  यदि तर्क के रूप में दी गई सूची वैध है तो सूची को sफिर से जांचे गए विज्ञापन के साथ घटा दिया जाता है ।
  अन्यथा परिणाम हैFalse