Được giới thiệu bởi một video youtube từ một người dùng PPCG đồng nghiệp ...

Bạn thách thức là sử dụng nghệ thuật ASCII vẽ một bức tường lâu đài Minecraft của Andesite và Diorite. Hình dạng của bức tường là Bộ Cantor . Để tham khảo, Bộ Cantor được tạo bằng cách lặp lại N lần sau:

• Tăng gấp ba bước hiện tại
• Thay thế cái ở giữa bằng khoảng trống
• Thêm một dòng đầy đủ bên dưới nó

Điều này tạo ra các bước sau cho bốn bước đầu tiên:

*

* *
***

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

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

Tuy nhiên, thử thách của bạn không hoàn toàn đơn giản. Bạn thấy đấy, sau khi bộ ca ca trở nên thực sự lớn, sẽ trở nên nhàm chán khi nhìn vào cùng một nhân vật lặp đi lặp lại nhiều lần. Vì vậy, chúng tôi sẽ thay đổi điều đó bằng cách phủ một loạt các dấu hoa thị *và dấu thăng xen kẽ #. Bạn nên xen kẽ trên mỗi ba ký tự theo chiều ngang và trên mỗi hàng theo chiều dọc. (Tất nhiên để lại các khoảng trắng giống nhau) Ví dụ: ví dụ thứ hai sẽ trở thành:

* *
###

và ví dụ thứ ba sẽ trở thành:

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

Để hoàn thiện, đây là ví dụ bốn và năm:

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

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

Và một ví dụ lớn , lần lặp thứ 6:

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

Các thách thức

Bạn phải viết một chương trình hoặc hàm đầy đủ chấp nhận một số nguyên dương cho đầu vào và xuất ra thế hệ thứ N của fractal Castle minecraft này. Bạn có thể lấy Đầu vào và đầu ra bằng bất kỳ phương pháp hợp lý nào và bạn không phải lo lắng về các đầu vào không hợp lệ (chẳng hạn như số nhỏ hơn 1, số dấu phẩy động, số không, v.v.).

Câu trả lời ngắn nhất, được đo bằng byte thắng!

Thạch , 43 36 35 byte

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

Chỉ cần bắt đầu, tôi chắc chắn điều này có thể ngắn hơn.

Hãy thử trực tuyến!

* Đối với n > 5, trình duyệt của bạn có thể bao bọc đầu ra nhưng nếu bạn sao chép-dán nó vào trình chỉnh sửa không gói, bạn sẽ thấy đầu ra thích hợp.

Giải trình

ḶṚ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

JavaScript (ES7), 132 125 byte

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`

Trường hợp \nđại diện cho characer dòng chữ mới. Phiên bản ES6 cho 141 byte:

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>

Python 2, 142 138 136 byte

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

Đây là đoạn mã từ đây , và sau đó được chỉnh sửa cho thử thách này.

Sẽ đăng một lời giải thích sau.

Ngoài ra, BTW, hai không gian là các tab.

Chỉnh sửa 1: 4 byte được lưu nhờ @DJMcMayhem.

Chỉnh sửa 2: 2 byte được lưu nhờ @daHugLenny.

Hồng ngọc 115 103 102 byte

->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}

Dựa trên giải pháp của jsvnm cho bộ golf tiêu chuẩn Cantor .

-12 byte nhờ Jordan.

J, 47 45 byte

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

Dựa trên giải pháp của tôi cho thử thách Cantor.

Sử dụng

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

Giải trình

' *#'{~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

PHP, 159 byte

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);

phá vỡ

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);