ABAA / ABBB: इस पुनरावर्ती 2 डी पैटर्न को उत्पन्न करें

Question

जब मैं निम्नलिखित दिलचस्प पुनरावर्ती पैटर्न में आया तो मैं अनंत प्रतिरोधक नेटवर्क (लंबी कहानी) के साथ खिलवाड़ कर रहा था:

|-||
|---

इस पैटर्न का प्रत्येक उदाहरण लंबा होने के साथ दोगुना चौड़ा है। पैटर्न के एक स्तर से अगले तक जाने के लिए, आप इस आयत को दो उप-खंडों में विभाजित करते हैं (जिनमें से प्रत्येक NxN वर्ग है):

AB =
|-||
|---

so A = 
|-
|-

and B = 
||
--

इन हिस्सों को फिर से निम्न पैटर्न के अनुसार दोहराया और पुनर्व्यवस्थित किया जाता है:

ABAA
ABBB

giving

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

चुनौती

एक प्रोग्राम / फ़ंक्शन लिखें, जो एक नंबर दिया गया है N, Nइस पुनरावर्ती डिजाइन के वें पुनरावृत्ति को आउटपुट करता है । यह गोल्फ है।

I / O प्रारूप अपेक्षाकृत उदार है: आप एक स्ट्रिंग, तार की एक सूची, वर्णों की एक 2 डी सरणी, आदि की वापसी कर सकते हैं। आप 0 या 1 अनुक्रमण का भी उपयोग कर सकते हैं।

उदाहरण

पैटर्न के पहले कई पुनरावृत्तियों निम्नानुसार हैं:

N = 0
|-

N = 1
|-||
|---

N = 2
|-|||-|-
|---|-|-
|-||||||
|-------

N = 3
|-|||-|-|-|||-||
|---|-|-|---|---
|-|||||||-|||-||
|-------|---|---
|-|||-|-|-|-|-|-
|---|-|-|-|-|-|-
|-||||||||||||||
|---------------

N = 4
|-|||-|-|-|||-|||-|||-|-|-|||-|-
|---|-|-|---|---|---|-|-|---|-|-
|-|||||||-|||-|||-|||||||-||||||
|-------|---|---|-------|-------
|-|||-|-|-|-|-|-|-|||-|-|-|||-|-
|---|-|-|-|-|-|-|---|-|-|---|-|-
|-|||||||||||||||-|||||||-||||||
|---------------|-------|-------
|-|||-|-|-|||-|||-|||-|||-|||-||
|---|-|-|---|---|---|---|---|---
|-|||||||-|||-|||-|||-|||-|||-||
|-------|---|---|---|---|---|---
|-|||-|-|-|-|-|-|-|-|-|-|-|-|-|-
|---|-|-|-|-|-|-|-|-|-|-|-|-|-|-
|-||||||||||||||||||||||||||||||
|-------------------------------

मुझे आश्चर्य है कि अगर इस संरचना की गणना करने के लिए कुछ लघु बीजीय तरीका है।

Comments

"बीजगणितीय" से आपका क्या तात्पर्य है?

— user202729

@ user202729 शायद कुछ "सरल" गणित फार्मूला है f(n,x,y)जो सीधे गणना कर सकता है कि किसी दिए गए समन्वय में होना चाहिए -या |। इसमें मॉडुलो ऑपरेशन या बिटवाइज़ ऑपरेशन शामिल हो सकते हैं। मैंने अभी तक जो तकनीकें देखी हैं उनमें सभी कटिंग / ज्वाइनिंग शामिल हैं जैसा कि कल्पना में दिखाया गया है।

— PhiNotPi

f(x,y)यह भी काम करता है, क्योंकि अगर x,yवैध है तो परिणाम पर निर्भर नहीं करता हैn

— amara

क्या आउटपुट 1-अनुक्रमित हो सकता है, अर्थात इनपुट 1 दे सकता है |-?

— जर्बद

क्या यह नुकसान है? 🤔

— qwr

Answer 1

APL (Dyalog Classic) , 29 25 बाइट्स

'|-'[{a,⊖⌽⍉~a←⍪⍨⍵}⍣⎕⍉⍪⍳2]

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

⍳2 वेक्टर है 0 1

⍪ इसे 2x1 मैट्रिक्स में बदल देता है

⍉ इसे स्थानांतरित करता है, इसलिए यह 1x2 हो जाता है

⎕ मूल्यांकन किया गया इनपुट

{ }⍣⎕ कई बार एक फ़ंक्शन लागू करें

⍪⍨⍵ एक 2x2 मैट्रिक्स - स्वयं के ऊपर तर्क को संक्षिप्त करें

a← के रूप में याद रखें a

~ निगेट

⍉ पक्षांतरित

⌽ क्षैतिज रूप से उल्टा

⊖ उल्टा खड़ा है

a,aबाईं ओर समतल करें

'|-'[ ]स्ट्रिंग में सूचकांकों के रूप में मैट्रिक्स का उपयोग करें '|-', यानी 0 में |और 1 बारी-

Answer 2

जावास्क्रिप्ट (Node.js) , 130 ... 106 94 92 बाइट्स

मेरे वैकल्पिक विधि से बनाए गए और पात्रों को ठीक करने के लिए, -14 बाइट्स धन्यवाद @ शगुन

f=n=>n?f(n-1).replace(/.+/g,x=>(g=i=>x.replace(/./g,p=>p<i?s[i]+s[i]:s))`0`+`
`+g`1`):s="|-"

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

मेरा मूल दृष्टिकोण ( 106 102 बाइट्स)

f=n=>n?[0,1].map(j=>f(n-1).split`
`.map(x=>x+x.substr((i=x.length/2)*j,i).repeat(2)).join`
`).join`
`:"|-"

-4 बाइट्स

f=n=>n?[0,1].map(j=>f(n-1).split`
`.map(x=>x+(y=x.substr((i=x.length/2)*j,i))+y).join`
`).join`
`:"|-"

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

स्पष्टीकरण और असंगठित:

function f(n) {                     // Main Function
 if (n != 0) {                      //  If n != 0: (i.e. not the base case)
  return [0, 1].map(                //   Separate the pattern into 2 parts
  function(j) {                     //   For each part:
   return f(n - 1).split("\n")      //    Split the next depth into lines
    .map(function(x) {              //    For each line in the result:
    return x                        //     The common part: "AB"
     + x.substr(
      (i = x.length / 2) * j        //     Take A if j == 0, B if j == 1
      , i                           //     Take half the original length
     ).repeat(2);                   //     Double this part
   }).join("\n");                   //    Join all lines together
  }).join("\n");                    //   Join the two parts together
 }
 else return "|-";                  //  If not (base case): return "|-";
}

मेरी मूल वैकल्पिक विधि, यदि "|"->"2", "-"->"1"अनुमति हो, तो १०५ १०४ बाइट्स:

f=n=>n?f(n-1).replace(/[12]+/g,x=>(g=(y,i)=>y.replace(/1|2/g,p=>[,i?11:22,21][p]))(x,0)+`
`+g(x,1)):"21"

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

बस इस समस्या के प्रति कुछ बीजीय पद्धति का पता लगाया।

x=>y=>"|-||--"[(f=(x,y,t=0,m=2**30,i=!(y&m)*2+!(x&m)<<1)=>m?f(x^m,y^m,([18,0,90][t]&3<<i)>>i,m>>1):t)(x>>1,y)*2+x%2]

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

(अंत में एक समारोह जो मेरे मूल उत्तर की तुलना में लंबा है)

f(n, x, y)nनिम्नलिखित प्रतिस्थापन के वें पुनरावृत्ति पर ब्लॉक (x, y) ब्लॉक प्रकार की गणना करता है :

0 => 0 1      1 => 0 0      2 => 1 1
     0 2           0 0           2 2

कहाँ से 0 = "|-", 1 = "||", 2 = "--", शुरू f(0, 0, 0) = 0।

फिर, g(x)(y)मूल पैटर्न के प्रतीक (x, y) पर गणना करता है।

Comments

अपने पहले समाधान के लिए 102 बाइट्स ।

— झबरा

अपने दूसरे के लिए 88 बाइट्स ।

— झबरा

95 बाइट्स के

— झबरा

^ 94 बाइट्स

— झबरा

92 बाइट्स

— झबरा

Answer 3

स्टैक्स , 24 17 15 बाइट्स

╛ä├¼àz[{╧↑;ε╖>╠

इसे चलाएं और डीबग करें

यहाँ एक ही कार्यक्रम के ascii प्रतिनिधित्व है।

'|'-{b\2*aa+c\}N\m

मूल विचार 0-पीढ़ी के ग्रिड से शुरू होता है, और फिर एक ब्लॉक को दोहराता है जो ग्रिड का विस्तार करता है।

'|'-                    Push "|" and "-"
     {         }N       Get input and repeat block that many times.
      b                 Copy two top stack values
       \2*              Zip two parts, and double the height
          aa            Roll the top of the stack down to 3rd position.
            +           Concatenate two grids vertically
             c\         Copy result and zip horizontally
                  \     Zip the two parts horizontally
                   m    Output each row

Answer 4

कैनवस , 17 16 बाइट्स

|∙-╶［∔αω＋：∔；：＋｝＋

यहाँ कोशिश करो!

स्पष्टीकरण, 1 के इनपुट के लिए स्टैक दिखा रहा है:

|∙-               push "|" and "-" - the initial halves  "|", "-"
   ╶[         }   repeat input times                     
     ∔              add the two parts vertically         "|¶-"
      αω            get the original arguments to that   "|¶-", "|", "-"
        +           and add those horizontally           "|¶-", "|-"
         :∔         and add to itself vertically         "|¶-", "|-¶|-"
           ;        get the vertically added parts       "|-¶|-", "|¶-"
            :+      and add to itself horizontally       "|-¶|-", "||¶--"
               +  finally, add the halves together       "|-||¶|---"

बग को ठीक करने के लिए 16 बाइट्स पर अपडेट किया गया, जहां α/ ωकाम करने के लिए निर्धारित मान ठीक से कॉपी नहीं किए गए थे (कैनवास को पूरी तरह से अपरिवर्तनीय माना जाता है, लेकिन, अफसोस, यह नहीं था)।

Answer 5

पायथन 2 , 88 77 बाइट्स

^{-11 बाइट्स लिन को थैंक्स}

f=lambda x:x<1and['|-']or[n+2*n[i:i+2**x/2]for i in(0,2**x/2)for n in f(x-1)]

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

Comments

आप 77 के लिए उन सूची समझ को एक साथ जोड़ सकते हैं:f=lambda x:x<1and['|-']or[n+2*n[i:i+2**x/2]for i in(0,2**x/2)for n in f(x-1)]

— लिन

Answer 6

पर्ल 5 , 72 बाइट्स

@1='|-';$l=@1,map{/.{$l}/;push@1,$_.$' x2;$_.=$&x2}@1for 1..<>;say for@1

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

Comments

इसके लिए अनुकूलित 66: $.=map{s/.{$.}$/$&$$ /,push@1,$। $ & X3} @ 1for (@ 1 = "| -") x <>, @ 1` के लिए कहें

— टन इंजील

Answer 7

भूसी , 17 बाइट्स

!¡§z+DȯṁmDTm½;"|-

1 अनुक्रमित। इसे ऑनलाइन आज़माएं!

व्याख्या

!¡§z+DȯṁmDTm½;"|-  Implicit input: a number n.
              "|-  The string "|-".
             ;     Wrap in a list: ["|-"]
 ¡                 Iterate this function on it:
                    Argument is a list of lines, e.g. L = ["|-||","|---"]
           m½       Break each line into two: [["|-","||"],["|-","--"]]
          T         Transpose: [["|-","|-"],["||","--"]]
      ȯṁ            Map and concatenate:
        mD           Map self-concatenation.
                    Result: ["|-|-","|-|-","||||","----"]
   z+               Zip using concatenation
  §  D              with L concatenated to itself: ["|-|||-|-","|---|-|-","|-||||||","|-------"]
                   Result is the infinite list [["|-"],["|-||","|---"],["|-|||-|-","|---|-|-","|-||||||","|-------"],...
!                  Take n'th element, implicitly display separated by newlines.

Answer 8

जेली , 21 19 बाइट्स

;"/;`,Ẏ;`€$
⁾|-Ç¡ZY

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

---

स्पष्टीकरण:

प्रारंभ में, मान है ⁾|-, जो है ["|","-"]।

अंतिम लिंक ( Ç), दिया गया [A, B], वापस आ जाएगा

   AB     AA
[  AB  ,  BB  ]

। ¡बार-बार समय की आखिरी कड़ी (इनपुट) संख्या, और लागू ZYयह प्रारूपों।

अंतिम लिंक के लिए स्पष्टीकरण:

-----------------
;"/;`,Ẏ;`€$  Monadic link. Value = [A, B]
;"/          Accumulate vectorized concatenate. Calculates (A ;" B).
             Represented as a matrix, it's |AB| (concatenated horizontally)
   ;`        Concatenate with self.      |AB|
                                Value =  |AB|  (concatenate vertically)
     ,    $  Pair with ...
      Ẏ        Tighten.  |A|    (concatenate vertically)
                 Value = |B|
       ;`€     Concatenate each with self.    |AA|
                                      Value = |BB|  (duplicate horizontally)

Answer 9

क्लीन , 121 106 बाइट्स

import StdEnv
$0=[['|-']]
$n#z=map(splitAt(2^n/2))($(n-1))
=[u++v++u++u\\(u,v)<-z]++[u++v++v++v\\(u,v)<-z]

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

Answer 10

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

(%)=zipWith(++)
f 0=["|-"]
f n|(a,b)<-unzip$splitAt(2^(n-1))<$>f(n-1)=a%b%a%a++a%b%b%b

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

बहुत साधारण। आउटपुट स्ट्रिंग्स की एक सूची है। हम पिछले संस्करण को लेते हैं और प्रत्येक पंक्ति को आधे हिस्से में विभाजित करते हैं और फिर उन दो नई सूचियों का उपयोग करके इकट्ठा करते हैं unzip। फिर यह सही तरीके से सरणियों के संयोजन की बात है

Answer 11

जे , 49 बाइट्स

f=.3 :'''|-''{~((,.[:|.[:|."1[:|:-.)@,~)^:y,:0 1'

Ngn's APL समाधान का एक अनाड़ी अनुवाद। मुझे इसे शांत करने में समस्या थी - मैं किसी भी सलाह को लागू करूँगा।

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

Answer 12

चारकोल , 47 46 बाइट्स

Ｍ²↖|-¶¶ＦＥＮＸ²ι«Ｆ²Ｃ±ι⁰Ｃ⁰ιＣ⊗ι±ιＣ׳ι±ι≦⊗ιＭ±ι±ιＴ⊗ιι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｍ²↖|-¶¶

निम्नलिखित लूप के लिए एक सुसंगत कर्सर स्थिति प्राप्त करने के लिए, मुझे चरण 0 को स्थिति (-2, -2) पर प्रिंट करना होगा और कर्सर को (-2, 0) पर छोड़ना होगा। (यह चारकोल में एक बग के कारण हो सकता है।)

ＦＥＮＸ²ι«

N2 की पहली शक्तियों पर लूप ।

Ｆ²Ｃ±ι⁰Ｃ⁰ιＣ⊗ι±ιＣ׳ι±ι

पिछले आउटपुट की प्रतियां विभिन्न ऑफसेट के साथ बनाएं जिसके परिणामस्वरूप एक कैनवास होता है जिसमें उसके भीतर एक आयत में वांछित अगला चरण होता है।

≦⊗ιＭ±ι±ιＴ⊗ιι

उस आयत की स्थिति में जाएँ और कैनवास ट्रिम करें।

वैकल्पिक समाधान, 46 बाइट्स:

Ｍ²→|-ＦＥＮＸ²ι«Ｆ432Ｃ×Ｉκι׳ιＦ245Ｃ×Ｉκι⊗ι≦⊗ιＪ⊗ιιＴ⊗ιι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｍ²→|-

इस बार चरण 0 को स्थिति (2, 0) पर मुद्रित किया जाना है, लेकिन कम से कम कर्सर की स्थिति कोई मायने नहीं रखती है।

ＦＥＮＸ²ι«

N2 की पहली शक्तियों पर लूप ।

Ｆ432Ｃ×Ｉκι׳ιＦ245Ｃ×Ｉκι⊗ι

पिछले आउटपुट की प्रतियां विभिन्न ऑफसेट के साथ बनाएं जिसके परिणामस्वरूप एक कैनवास होता है जिसमें उसके भीतर एक आयत में वांछित अगला चरण होता है।

≦⊗ιＪ⊗ιιＴ⊗ιι

उस आयत की स्थिति में जाएँ और कैनवास ट्रिम करें।

Answer 13

आर , 126 बाइट्स

function(n,k=cbind){o=matrix(c("|","-"),1,2)
if(n>0)for(i in 1:n)o=rbind(k(a<-o[,x<-1:(2^(i-1))],b<-o[,-x],a,a),k(a,b,b,b))
o}

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

रिटर्न ए matrix। सत्यापन में आसानी के लिए इसे अच्छी तरह से प्रिंट करने के लिए TIO लिंक में थोड़ा सा कोड है।

Comments

110

— रॉबिन राइडर

Answer 14

के (ngn / k) , 25 बाइट्स

{"|-"x{x,'|+|~x:x,x}/,!2}

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

Answer 15

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 67 65 बाइट्स

SubstitutionSystem[{"|"->{i={"|","-"},i},"-"->{i,i}},{i},{#}]&

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

पुनरावृत्ति का सीधा कार्यान्वयन। किसी सूची में लिपटे हुए वर्णों की एक सरणी देता है।