फाइबोनैचि डोमिनोज टाइलिंग

Question

नहीं है क्लासिक मिश्रित परिणाम है कि टाइल करने के लिए तरीके की संख्या एक 2*nसे पट्टी 1*2डोमिनो n है ^वें फिबोनैकी संख्या। आप लक्ष्य के लिए दिए गए सभी झुकावों को प्रिंट करना चाहते हैं n, डैश और ऊर्ध्वाधर रेखाओं के साथ इन 8 झुकावों के लिए n=5:

|————
|————

——|——
——|——

|||——
|||——

————|
————|

||——|
||——|

|——||
|——||

——|||
——|||

|||||
|||||

आपको एक प्रोग्राम या नामित फ़ंक्शन प्रदान करना है जो nइनपुट के रूप में लेते हैं और आवश्यक आउटपुट प्रिंट करते हैं। सबसे कम बाइट्स जीतता है।

इनपुट

STDIN या फ़ंक्शन इनपुट के माध्यम से एक संख्या के nबीच 1और 10समावेशी।

उत्पादन

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

एक वर्टिकल डोमिनोज़ दो वर्टिकल बार्स ( |) से बना होता है और एक हॉरिज़ॉन्टल डोमिनोज़ दो एम डैश ( —) से बना होता है। आप -ASCII में रहने के लिए em dashes के स्थान पर hyphens ( ) का उपयोग कर सकते हैं ।

आप व्हॉट्सएप के साथ कुछ भी कर सकते हैं जब तक कि प्रिंटेड आउटपुट एक जैसा दिखता है।

Comments

व्हॉट्सएप के साथ किसी भी चीज के नीचे गिरने के बाद एक अतिरिक्त लाइनफेड होगा ?

— डेनिस

@ डेनिस हां, अतिरिक्त खाली लाइनें ठीक हैं।

— xnor

मैं वास्तव में एक ही समस्या को हल करने के लिए कई अलग-अलग तरीकों को देखकर आश्चर्यचकित हूं। क्या आपको इसकी उम्मीद थी?

— लेवल रिवर सेंट

@steveverrill नहीं, मैं पूरी तरह से नहीं था, और विविधता को देखकर खुश हूं! और तुम्हारा केक अप्रत्याशितता के लिए लेता है। मैंने ज्यादातर फाइबोनैचि-शैली की पुनरावृत्ति को ध्यान में रखा था, क्योंकि अधिकांश समाधान मैंने उपयोग किए थे। मैं फ़िल्टरिंग के प्रभावी होने की उम्मीद नहीं करता था, और मैंने जितना किया था, मुझे हालांकि यह डेनिस की तरह तार को ——और |लंबाई से फ़िल्टर करना होगा , न कि लंबाई के- nस्ट्रिंग —और जोड़ियों में दिखने के |द्वारा फ़िल्टर किया गया —। और बाद के लिए, मैं उम्मीद करूँगा कि यह आपके s.split('——द्वारा एक अंकगणितीय दृष्टिकोण द्वारा नहीं, बल्कि निर्मित स्ट्रिंग पर regexes या स्ट्रिंग संचालन के माध्यम से होगा ।

— 19

मुझे लगता है कि "1x2 डोमिनोज़" बेमानी है।

— सुपरजेडी २२४

Answer 1

सी, 106

गोल्फ संस्करण

f(n){
  for(int i,h=n*2<<n;h--;(i/3|i/3*2)-i||(putchar(i>>h%n&1?45:124),h%n||puts(h%(n*2)?"":"\n")))
    i=h/2/n;
}

मूल संस्करण

i,j,n;
main(){
  scanf("%d",&n);
  for(i=1<<n;i--;)if((i/3|i/3*2)==i){
    for(j=1<<n;j/=2;)printf("%c",i&j?'-':'|');puts("");
    for(j=1<<n;j/=2;)printf("%c",i&j?'-':'|');puts("\n");
  }
}

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

चर नीचे से 0 iतक चलता है 1<<n-1, nअंकों के साथ सभी संभव बाइनरी नंबर का उत्पादन करता है । के लिए 0 एनकोड |और 1 के लिए एनकोड -। हम उन संख्याओं में रुचि रखते हैं जिनमें जोड़े में 1 है। जाहिर है ऐसी संख्या 3 से विभाज्य है।

जब किसी संख्या को 3 से विभाजित किया जाता है, तो मूल संख्या को परिणाम को 2 से गुणा करके और इसे स्वयं में जोड़कर (प्रभावी रूप से 3. से परस्पर प्रभावित करके) पुनर्प्राप्त किया जा सकता है। अधिकांश संख्याओं में कैरी की आवश्यकता होती है, लेकिन जब प्रक्रिया को संख्याओं पर किया जाता है ब्याज, कैरी की आवश्यकता नहीं होती है, इसलिए इन मामलों में, या इसके अलावा इस्तेमाल किया जा सकता है। यह ब्याज की संख्या के लिए परीक्षण करने के लिए उपयोग किया जाता है, क्योंकि वे केवल वही हैं जहां अभिव्यक्ति i/3|i/3*2मूल मूल्य लौटाती है i। नीचे उदाहरण देखें।

1111= 15 ---> 0101= 5 ---> 1111= 15 (मान्य, 0101|1010== 0101+1010)

1001= 9 ---> 0011= 3 ---> 0111= 7 (अमान्य; 0011|0110= 0011+0110)

परीक्षण मूल्य हमेशा मूल मूल्य से बराबर या कम होता है। जैसे कि संख्याएँ जो 3 के गुणक नहीं हैं, वे भी मूल से कम संख्या में लौटती हैं जब 3 से विभाजित किया जाता है तो 3 से गुणा किया जाता है, परीक्षण इन संख्याओं पर वांछित FALSE भी देता है।

मूल संस्करण में दो छोरों का jउपयोग बिट्स के माध्यम से स्कैन करने iऔर आउटपुट का उत्पादन करने के लिए किया जाता है। गोल्फ संस्करण में एक एकल forलूप का उपयोग किया जाता है, जिसमें hसभी संख्याओं के माध्यम से (n*2)*(1<<n)-1नीचे से लेकर 0. मान तक iउत्पन्न होता है h/2/n। चर jका उपयोग नहीं किया जाता है, क्योंकि बराबर मात्रा से प्राप्त किया जाता है h%n। n*2दोनों पंक्तियों का उपयोग एक ही लूप से प्रिंट करने के लिए सक्षम करता है, putsबयान में कुछ निफ्टी मल्टीप्लेक्सिंग के साथ पंक्ति के अंत में एक या दो नईलाइनों को प्रिंट करने के लिए।

ध्यान दें कि इस का मांस for()ब्रैकेट की वृद्धि की स्थिति में है और इसलिए इसके बाद निष्पादित किया जाता है i=h/2/h।

नमूना आउटपुट n = 6:

$ ./a
6
------
------

----||
----||

--|--|
--|--|

--||--
--||--

--||||
--||||

|----|
|----|

|--|--
|--|--

|--|||
|--|||

||----
||----

||--||
||--||

|||--|
|||--|

||||--
||||--

||||||
||||||

Comments

i/3|i/3*2चाल सरल है! मुझे व्याकरण के लिए एक अंकगणितीय अभिव्यक्ति की उम्मीद नहीं थी।

— 20

Answer 2

CJam, 33 27 बाइट्स

LN{_'|f+@"——"f++}ri*\;{_N}/

6 बाइट बंद करने के लिए @ jimmy23013 को धन्यवाद!

इसे ऑनलाइन आज़माएं!

पृष्ठभूमि

यह एक पुनरावर्ती एल्गोरिदम का पुनरावृत्त कार्यान्वयन है:

के लिए संभव टाइलिंग n के लिए संभव टाइलिंग के लिए एक ऊर्ध्वाधर डोमिनो जोड़कर प्राप्त किया जा सकता है 1 - एन और दो क्षैतिज डोमिनोज के लिए संभव टाइलिंग के लिए n - 2 ।

इस तरह, n के लिए झुकाव की संख्या n - 1 और n - 2 के लिए tilings की संख्या का योग है , अर्थात, n ^वें फाइबोनैचि संख्या।

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

LN                                " A:= [''] B:= ['\n']                         ";
  {             }ri*              " Repeat int(input()) times:                  ";
   _'|f+                          "   C = copy(B); for T ∊ C: T += '|'          ";
              @                   "   Swap A and B.                             ";
               "——"f+             "   for T ∊ B: T += "——"                      ";
                     +            "   B = C + B                                 ";
                        \;        " Discard A.                                  ";
                          {_N}/   " for T ∊ B: print T, T + '\n'                ";

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

$ alias cjam='java -jar cjam-0.6.2.jar'

$ cjam domino.cjam <<< 3
|||
|||

——|
——|

|——
|——

$ for i in {1..10}; do echo $[$(cjam domino.cjam <<< $i | wc -l) / 3]; done1
2
3
5
8
13
21
34
55
89

Comments

LNli{_'|f\@"——"f\+2/}*\;{_N}/।

— jimmy23013

f\0.6.2 में अभी तक लागू नहीं किया गया था, लेकिन मैं हमारे दृष्टिकोणों को संयोजित करने में सक्षम था। धन्यवाद!

— डेनिस

Answer 3

हास्केल, 89 बाइट्स

f(-1)=[]
f 0=[""]
f n=map('|':)(f$n-1)++map("--"++)(f$n-2)
g=unlines.(>>= \x->[x,x,""]).f

fएक ऐसा फंक्शन है, जिसमें एक नंबर दिया गया है, लंबाई n के सभी संभावित फाइबोनैचि झुकाव की एक पंक्ति की सूची देता है। इससे कोई फर्क नहीं पड़ता कि यह एक लाइन लौटाता है, क्योंकि सभी झुकावों की दोनों लाइनें समान हैं।

fपर पुनरावर्ती फोन करके काम करता है n-1और n-2और जोड़ने "|"और "--"तार करने के लिए (क्रमशः)।

gवह फ़ंक्शन है जो प्रश्नों का उत्तर देता है। यह मूल रूप fसे इनपुट पर कॉल करता है, हर स्ट्रिंग को दोगुना करता है, ताकि यह दो लाइनें दिखा सके और उन सभी को नए सिरे से जोड़ दे।

उदाहरण आउटपुट:

*Main> putStrLn $ g 5
|||||
|||||

|||--
|||--

||--|
||--|

|--||
|--||

|----
|----

--|||
--|||

--|--
--|--

----|
----|

Answer 4

सीजेएम, 42 37 बाइट्स

3li:L#,{3b"——|"2/f=s}%{,L=},_&{N+_N}/

मैंने डैश को एक बाइट के रूप में गिना है क्योंकि प्रश्न ASCII हाइफ़न के साथ उन्हें बदलने की अनुमति देता है।

इसे ऑनलाइन आज़माएं।

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

2 × L के सभी संभव झुकाव प्राप्त करने के लिए , हम सभी गैर-नकारात्मक पूर्णांक I <3 ^L पर पुनरावृत्ति करते हैं , जिससे आधार 3 में भी अंक क्षैतिज वर्चस्व और ऊर्ध्वाधर से विषम अंकों के अनुरूप हो जाते हैं।

चूंकि प्रत्येक I के पास आधार 3 में L या कम अंक हैं, यह 2 × L पट्टी को कवर करने के सभी संभावित तरीके उत्पन्न करता है । जो कुछ बचा है उसे कवरिंग को फ़िल्टर करना है जो 2 × L से बड़ा या छोटा है और शेष कवरिंग प्रिंट करें।

3li:L#,      " Read an integer L from STDIN and push A := [ 0 1 ... (3 ** N - 1) ].       ";
{            " For each integer I in A:                                                   ";
  3b         " Push B, the array of I's base 3 digits.                                    ";
  "——|"2/    " Push S := [ '——' '|' ].                                                    ";
  f=         " Replace each D in B with S[D % 2] (the modulus is implicit).               ";
  s          " Flatten B.                                                                 ";
}%           " Collect the result in an array R.                                          ";
{,L=},       " Filter R so it contains only strings of length L.                          ";
_&           " Intersect R with itself to remove duplicates.                              ";
{N+_N}/      " For each string T in B, push (T . '\n') twice, followed by '\n'.           ";

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

$ cjam domino.cjam <<< 3
|——
|——

——|
——|

|||
|||

$ for i in {1..10}; do echo $[$(cjam domino.cjam <<< $i | wc -l) / 3]; done
1
2
3
5
8
13
21
34
55
89

Comments

ठंडा। मैं सिर्फ यह सोच रहा हूं कि आपने आधार के बजाय edc65 जैसे बेस 2 का उपयोग क्यों नहीं किया। इससे आपको डुप्लिकेट होने से बचाया जा सकता है। मुझे लगता है यह है क्योंकि अग्रणी शून्य शायद कदम में छोटा हो गया है 3b। क्या वह सही है?

— लेवल रिवर सेंट

@steveverrill: हाँ, यह ठीक कारण है। जैसा कि यह है, अग्रणी शून्य बिल्कुल भी डोमिनोज़ के अनुरूप नहीं है। लेकिन डुप्लिकेट नहीं होने से मुझे एक के साथ तीन ब्लॉकों को बदलने की अनुमति मिलेगी। मुझे इसके बारे में कुछ और सोचना पड़ेगा।

— डेनिस

@steveverrill: मैंने आधार 2 कार्य करने का प्रबंधन नहीं किया, लेकिन एक पुनरावर्ती दृष्टिकोण और भी छोटा प्रतीत होता है।

— डेनिस

Answer 5

जावास्क्रिप्ट (E6) 102

बिट क्रम से विन्यास उत्पन्न करें, 0 -> '-' और 1 -> '|'

F=n=>{
  for(i=0;(j=++i)<2<<n;s.length==1+n&&console.log('\n'+s+s))
    for(s='\n';j>1;j>>=1)s+=j&1?'|':'--';
}

फ़ायरफ़ॉक्स / फ़ायरबग कंसोल में टेस्ट करें

F(5)

उत्पादन

|----
|----

--|--
--|--

----|
----|

|||--
|||--

||--|
||--|

|--||
|--||

--|||
--|||

|||||
|||||

Answer 6

हास्केल: 109 बाइट्स

यह फाइबोनैचि संख्याओं के क्रम की गणना करने के लिए प्रसिद्ध हास्केल वन-लाइनर का अनुवाद है:

b=map.map.(++)
w=zipWith
z=w(++)
s=["\n"]:["|\n"]:z(b"--"s)(b"|"$tail s)
f=sequence_.map putStrLn.(w z s s!!)

तार के मुख्य अनुक्रम, ungolfed:

dominos = [""] : ["|"] : zipWith (++) ("--" `before` dominos) ("|" `before` tail dominos)
    where before = map . map . (++)

और तुलना के लिए फाइबोनैचि वन-लाइनर:

fibs = 0 : 1 : zipWith (+) fibs (tail fibs)

उपयोग उदाहरण:

$ ghci fibtile
GHCi, version 7.6.3: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
[1 of 1] Compiling Main             ( fibtile.hs, interpreted )
Ok, modules loaded: Main.
*Main> f 5
----|
----|

--|--
--|--

--|||
--|||

|----
|----

|--||
|--||

||--|
||--|

|||--
|||--

|||||
|||||

*Main>

Answer 7

कोबरा - 176

जब तक मैं कोबरा गोल्फ पैकेज खत्म नहीं कर लेता, तब तक इंतजार नहीं कर सकता।

def m(n)
    for t in.f(n),print t+t
def f(n,x='')as String*
    if x.length<n,for i in.f(n,x+'-').toList+.f(n,x+'|').toList,yield i
    else if not'-'in x.replace('--',''),yield x+'\n'

Answer 8

जे - 54 चार

nदाईं ओर तर्क के रूप में कार्य करना ।

0{::(];'--'&,"1@[,'|',"1])&>/@[&0&((1 2$,:)&.>'';,'|')

इस गोल्फ की मुख्य जड़ है (];'--'&,"1@[,'|',"1])&>/। यह लंबाई (N-2) और (N-1) के झुकाव की एक सूची लेता है, और लंबाई (N-1) के झुकाव की सूची देता है और N। यह मानक फाइबोनैचि पुनरावृत्ति, अ ला रेखीय बीजगणित है। ];नई बाईं के रूप में सही सूची देता है (जैसा कि कोई परिवर्तन नहीं है)। '--'&,"1@[कहते हैं --छोड़ दिया सूची में टाइल्स, जबकि '|',"1]कहते हैं |सही सूची में टाइल्स, और उन एक साथ नई सही सूची है।

हम उस पर और nसमय के साथ पुनरावृत्ति करते हैं (यह @[&0) और खाली टाइलिंग और लंबाई के एकल टाइलिंग के साथ शुरू करते हैं। 1. फिर हम जोड़ी के पहले भाग के साथ लौटते हैं 0{::। मतलब, अगर हम इसे शून्य बार चलाते हैं, तो हम केवल पहले यानी खाली टाइलिंग को वापस करते हैं। यदि हम इसे nबार चलाते हैं , तो हम n( n+1) जोड़ी की गणना करते हैं , लेकिन बाद को छोड़ देते हैं। यह अतिरिक्त काम है लेकिन कम पात्र हैं।

(1 2$,:)कुछ जम्मू आदेश सूचियों में टाइलिंग आसानी से बढ़ाई बनाने के लिए क्या करना है। हम बाईं सूची को पात्रों की 2-पंक्ति मैट्रिक्स की 1-आइटम सूची बनाते हैं, प्रत्येक पंक्ति की लंबाई 0. होती है। सही शुरुआत सूची समान होती है, लेकिन पंक्तियों की लंबाई 1 से होती है, जिसके साथ भरा होता है |। फिर, हम प्रत्येक पंक्ति में नई टाइलें जोड़ते हैं, और जब हम एक साथ झुकाव के दो सेटों में शामिल हो रहे होते हैं, तो मैट्रिसेस की सूचियों को जोड़ते हैं। यह एक अवधारणा का एक सरल अनुप्रयोग है जे कॉल रैंक: अनिवार्य रूप से अपने तर्कों की गतिशीलता में हेरफेर, और आवश्यक होने पर अंतर्निहित लूपिंग।

   0{::(];'--'&,"1@[,'|',"1])&>/@[&0&((1 2$,:)&.>'';,'|')5
----|
----|

--|--
--|--

--|||
--|||

|----
|----

|--||
|--||

||--|
||--|

|||--
|||--

|||||
|||||

इसे अपने लिए tryj.tk पर आजमाएँ ।

Answer 9

पायथन 3: 70 बाइट्स

f=lambda n,s="\n":n>0and f(n-1,"|"+s)==f(n-2,"--"+s)or n or print(s*2)

पुनरावर्ती डोमो की sएक पंक्ति का प्रतिनिधित्व करने वाले सभी संभावित तारों का निर्माण करता है , जो डुप्लिकेट और मुद्रित होते हैं। sन्यूलाइन कैरेक्टर के रूप में शुरू करने से ब्लैंक लाइन अपने आप हो जाती है।

के ==लिए दो कॉल के बीच fदोनों फ़ंक्शन कॉल करने के लिए है। ये आमतौर पर वापस लौटते हैं Noneक्योंकि वे सिर्फ प्रिंट करते हैं, और ==कुछ ऑपरेटरों में से एक है जिनके लिए परिभाषित किया गया है None।

andऔर orरों पुन: पेश करने के लिए सही शॉर्ट-सर्किट व्यवहार का उत्पादन कर रहे हैं ifऔर elseungolfed कोड की रों।

Ungolfed:

def f(n,s="\n"):
 if n==-1:pass
 elif n==0: print(s*2)
 else: f(n-1,"|"+s);f(n-2,"--"+s)

Answer 10

रेटिना , 44 बाइट्स

नोट: रेटिना इस चुनौती से छोटी है।

+`([-|]*)11(1*#)
$1|1$2$1--$2
1
|
.*?#
$0$0#

एक अनुगामी न्यूलाइन के साथ एकरी में इनपुट लेता है।

प्रत्येक पंक्ति को अपनी फ़ाइल पर #जाना चाहिए और फ़ाइल में नई पंक्ति में बदलना चाहिए। यह अव्यवहारिक है, लेकिन आप कोड को -sध्वज के साथ एक फ़ाइल के रूप में चला सकते हैं , #मार्करों को रखते हुए (और #इनपुट में नईलाइन को भी बदल सकते हैं)। #अगर तुम चाहो तो पठनीयता के उत्पादन में नई कहानियों को बदल सकते हो । उदाहरण के लिए:

> echo 1111# | retina -s fib_tile | tr # '\n'
||||
||||

||--
||--

|--|
|--|

--||
--||

----
----

तरीका:

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

Comments

अनुगामी न्यूलाइन ठीक है।

— xnor