Minecraft महल भग्न

Question

एक PPCG उपयोगकर्ता से एक youtube वीडियो द्वारा किया गया ...

आपको चुनौती है कि आप ASCII- कला का उपयोग एन्डेसाइट और डायराइट की एक Minecraft महल की दीवार से करें। आकार की दीवार के है कैंटर सेट । संदर्भ के लिए, कैंटर सेट निम्नलिखित N बार दोहराकर बनाया जाता है:

• वर्तमान कदम ट्रिपल
• बीच वाले को खाली जगह से बदलें
• इसके नीचे एक पूरी लाइन जोड़ें

यह पहले चार चरणों के लिए निम्नलिखित बनाता है:

*

* *
***

* *   * *
***   ***
*********

* *   * *         * *   * *
***   ***         ***   ***
*********         *********
***************************

हालाँकि, आपकी चुनौती इतनी सरल नहीं है। आप देखते हैं, कैंटर सेट के वास्तव में बड़ा हो जाने के बाद, बार-बार एक ही चरित्र को देखना उबाऊ हो जाता है। इसलिए हम परिवर्तन करने जा रहे हैं कि तारांकन चिह्न *और पाउंड संकेतों की एक वैकल्पिक श्रृंखला को ओवरले करके #। आपको हर तीन वर्णों पर क्षैतिज रूप से और हर पंक्ति पर लंबवत रूप से वैकल्पिक करना चाहिए। (निश्चित रूप से रिक्त स्थान समान छोड़ते हुए) उदाहरण के लिए, दूसरा उदाहरण बन जाएगा:

* *
###

और तीसरा उदाहरण बन जाएगा:

* *   * *
###   ###
***###***

पूर्णता के लिए, यहां चार और पांच उदाहरण दिए गए हैं:

#4
* *   * *         * *   * *
###   ###         ###   ###
***###***         ***###***
###***###***###***###***###

#5
* *   * *         * *   * *                           * *   * *         * *   * *
###   ###         ###   ###                           ###   ###         ###   ###
***###***         ***###***                           ***###***         ***###***
###***###***###***###***###                           ###***###***###***###***###
***###***###***###***###***###***###***###***###***###***###***###***###***###***

और एक मेगा उदाहरण, 6 वें पुनरावृत्ति:

* *   * *         * *   * *                           * *   * *         * *   * *                                                                                 * *   * *         * *   * *                           * *   * *         * *   * * 
###   ###         ###   ###                           ###   ###         ###   ###                                                                                 ###   ###         ###   ###                           ###   ###         ###   ###
***###***         ***###***                           ***###***         ***###***                                                                                 ***###***         ***###***                           ***###***         ***###***
###***###***###***###***###                           ###***###***###***###***###                                                                                 ###***###***###***###***###                           ###***###***###***###***###
***###***###***###***###***###***###***###***###***###***###***###***###***###***                                                                                 ***###***###***###***###***###***###***###***###***###***###***###***###***###***
###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###***###

चुनौती

आपको एक पूर्ण प्रोग्राम या फ़ंक्शन लिखना होगा जो इनपुट के लिए एक सकारात्मक पूर्णांक को स्वीकार करता है, और इस मिनीक्राफ्ट फ्रैक्टल के एन 'वें पीढ़ी को आउटपुट करता है । आप किसी भी उचित विधि द्वारा इनपुट और आउटपुट ले सकते हैं, और आपको अमान्य इनपुट (जैसे संख्या 1 से कम संख्या, फ्लोटिंग पॉइंट नंबर, गैर-संख्या, आदि) के बारे में चिंता करने की ज़रूरत नहीं है।

सबसे छोटा जवाब, बाइट्स जीत में मापा जाता है!

Comments

संबंधित

— DJMcMayhem

Answer 1

जेली , 43 36 35 बाइट्स

ḶṚ3*µ5B¤xЀṁ€Ṁ×\Ṛ©1,‘xS$¤ṁ×®ị“*# ”Y

बस एक शुरुआत, मुझे यकीन है कि यह छोटा हो सकता है।

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

* N > 5 के लिए, आपका ब्राउज़र आउटपुट लपेट सकता है लेकिन यदि आप इसे नॉन-रैपिंग एडिटर में कॉपी-पेस्ट करते हैं, तो आपको उचित आउटपुट दिखाई देगा।

व्याख्या

ḶṚ3*µ5B¤xЀṁ€Ṁ×\Ṛ©1,‘xS$¤ṁ×®ị“*# ”Y  Input: integer n
Ḷ                                    Create the range [0, n)
 Ṛ                                   Reverse it
  3*                                 Raise 3 to the power of each
    µ                                Begin a new monadic chain on the powers of 3
     5B¤                             Nilad. Get the binary digits of 5 = [1, 0, 1]
        xЀ                          Duplicate each of [1, 0, 1] to a power of 3 times
             Ṁ                       Get the maximum of the powers of 3
           ṁ€                        Reshape each to a length of that value
              ×\                     Cumulative products
                Ṛ©                   Reverse and save the result
                  1,‘xS$¤            Niladic chain.
                  1                    Start with 1
                    ‘                  Increment it
                   ,                   Pair them to get [1, 2]
                       $               Operate on [1, 2]
                      S                  Sum it to get 3
                     x                   Repeat each 3 times to get [1, 1, 1, 2, 2, 2]
                         ṁ           Reshape that to the saved table
                          ×®         Multiply elementwise with the saved table
                            ị“*# ”   Use each to as an index to select from "*# "
                                  Y  Join using newlines
                                     Return and print implicitly

Answer 2

जावास्क्रिप्ट (ईएस 7), 132 125 बाइट्स

n=>[...Array(n)].map((_,i)=>[...Array(3**~-n)].map((_,j)=>/1/.test((j/3**i|0).toString(3))?" ":`*#`[j/3+i&1]).join``).join`\n`

जहाँ \nशाब्दिक न्यूलाइन चॅरसर का प्रतिनिधित्व करता है। ES6 संस्करण 141 बाइट्स के लिए:

f=
n=>[...Array(n)].map((_,i)=>[...Array(Math.pow(3,n-1))].map((_,j)=>/1/.test((j*3).toString(3).slice(0,~i))?" ":`*#`[j/3+i&1]).join``).join`
`
;

<input type=number min=1 oninput=o.textContent=f(+this.value)><pre id=o>

Answer 3

पायथन 2, 142 138 136 बाइट्स

r=range
def f(n):
 for i in r(n+1):
  s="";d=i%2<1
  for k in r(3**i):s+="#*"[(6+d-1+k*(d*2-1))%6<3]
  exec"s+=len(s)*' '+s;"*(n-i);print s

यह यहाँ से कोड का टुकड़ा है , और फिर इस चुनौती के लिए संपादित किया गया है।

बाद में स्पष्टीकरण पोस्ट करेंगे।

इसके अलावा, BTW, दो स्थान टैब हैं।

1: 4 बाइट संपादित करें @DJMcMayhem के लिए धन्यवाद सहेजा गया।

2 संपादित करें: 2 बाइट्स @daHugLenny के लिए धन्यवाद बचाए।

Comments

चूंकि यह पायथन 2 है, क्या आप कोष्ठक को हटा नहीं सकते exec("s+=len(s)*' '+s;"*(n-i))?

— एक्रोलिथ

@daHugLenny आह हाँ, धन्यवाद! (बहुत जल्द जवाब न देने के लिए खेद है)

— clismique

Answer 4

माणिक, 115 103 102 बाइट्स

->n{g=->{T.tr"*#","#*"}
*s=?*
(n-1).times{|i|T=s[-1]
s=s.map{|l|l+' '*3**i+l}+[i<1??#*3:g[]+T+g[]]}
s}

मानक कैंटर सेट गोल्फ में jsvnm के समाधान के आधार पर ।

-12 बाइट्स जॉर्डन के लिए धन्यवाद।

Comments

g=->{T.tr"*#","#*"}

— जॉर्डन

इसके अलावा, के s.map!{...}बजाय s=s.map{...};s।

— जॉर्डन

@ जोर्डन s.map! +को बदलने की आवश्यकता होगी <<, और यह एक ही लंबाई को समाप्त करेगा। मेरा मानना ​​है sकि अभी भी किसी भी तरह से अंत में आवश्यक है - नक्शा एक .timesलूप के अंदर है ।

— m-chrzan

आह, ठीक है तुम।

— जॉर्डन

Answer 5

जे, 47 45 बाइट्स

' *#'{~3(]*$@]$1 2#~[)(,:1)1&(,~],.0&*,.])~<:

कैंटर सेट चुनौती के लिए मेरे समाधान के आधार पर ।

प्रयोग

   f =: ' *#'{~3(]*$@]$1 2#~[)(,:1)1&(,~],.0&*,.])~<:
   f 1
*
   f 2
* *
###
   f 3
* *   * *
###   ###
***###***

व्याख्या

' *#'{~3(]*$@]$1 2#~[)(,:1)1&(,~],.0&*,.])~<:  Input: n
                                           <:  Decrement n
                      (,:1)                    A constant [1]
                           1&(           )~    Repeating n-1 times on x starting
                                               with x = [1]
                                        ]        Identity function, gets x
                                   0&*           Multiply x elementwise by 0
                                      ,.         Join them together by rows
                                ]                Get x
                                 ,.              Join by rows
                           1  ,~                 Append a row of 1's and return
       3                                       The constant 3
        (                 )                    Operate on 3 and the result
                    [                          Get LHS = 3
               1 2                             The constant [1, 2]
                  #~                           Duplicate each 3 times
                                               Forms [1, 1, 1, 2, 2, 2]
           $@]                                 Get the shape of the result
              $                                Shape the list of [1, 2] to
                                               the shape of the result
         ]                                     Get the result
          *                                    Multiply elementwise between the
                                               result and the reshaped [1, 2]
' *#'                                        The constant string ' *#'
     {~                                       Select from it using the result
                                             as indices and return

Answer 6

PHP, 159 बाइट्स

for($r=($n=--$argv[1])?["* *","###"]:["*"];++$i<$n;$r[]=$a.$b.$a){$a=strtr($b=end($r),"#*","*#");foreach($r as&$s)$s.=str_pad("",3**$i).$s;}echo join("\n",$r);

टूट - फूट

for(
    $r=($n=--$argv[1])  // pre-decrease argument, initialize result
    ?["* *","###"]      // shorter than handling the special iteration 2 in the loop
    :["*"]              // iteration 1
    ;
    ++$i<$n             // further iterations:
    ;
    $r[]=$a.$b.$a       // 3. concatenate $a, $b, $a and add to result
)
{
                        // 1. save previous last line to $b, swap `*` with `#` to $a
    $a=strtr($b=end($r),"#*","*#"); 
                        // 2. duplicate all lines with spaces of the same length inbetween
    foreach($r as&$s)$s.=str_pad("",3**$i).$s;  # strlen($s)==3**$i
}
// output
echo join("\n",$r);