Vẽ một fractal được lập chỉ mục

14

Giới thiệu

Trong thử thách này, ma trận 2 × 2 được lập chỉ mục như sau:

0 1
2 3

Chúng tôi xác định một họ các mẫu giống như fractal F(L), trong đó Llà một ndanh sách dài các chỉ số này và F(L)có kích thước .2n-1 × 2n-1

  • Nếu L == [], thì đó F(L)là mẫu 1 × 1 #.

  • Nếu L != [], sau đó F(L)được xây dựng như sau. Hãy Plà mẫu thu được từ Lvới phần tử đầu tiên được loại bỏ. Lấy bốn lưới có kích thước chứa đầy các dấu chấm và thay thế lưới được lập chỉ mục bằng mẫu . Sau đó, dán các lưới lại với nhau bằng cách sử dụng một lớp băm giữa chúng. Dưới đây là sơ đồ cho bốn trường hợp:2n-1-1 × 2n-1-1.L[0]P#

    L[0]==0  L[0]==1  L[0]==2  L[0]==3
   #...  ...#     ...#...  ...#...
[P]#...  ...#[P]  ...#...  ...#...
   #...  ...#     ...#...  ...#...
#######  #######  #######  #######
...#...  ...#...     #...  ...#   
...#...  ...#...  [P]#...  ...#[P]
...#...  ...#...     #...  ...#

Thí dụ

Hãy xem xét đầu vào L = [2,0]. Chúng tôi bắt đầu với lưới 1 × 1 #và đi qua Lbên phải. Phần tử ngoài cùng bên phải là 0, vì vậy chúng tôi lấy bốn bản sao của lưới 1 × 1 ., thay thế bản đầu tiên bằng cách #dán chúng lại với nhau bằng băm. Điều này dẫn đến lưới 3 × 3

##.
###
.#.

Phần tử tiếp theo là 2, vì vậy chúng tôi lấy bốn bản sao của lưới 3 × 3 .và thay thế phần thứ ba bằng lưới ở trên. Bốn lưới là

...  ...  ##.  ...
...  ...  ###  ...
...  ...  .#.  ...

và dán chúng cùng với #kết quả s trong lưới 7 × 7

...#...
...#...
...#...
#######
##.#...
####...
.#.#...

Đây là đầu ra cuối cùng của chúng tôi.

Đầu vào

Đầu vào của bạn là một danh sách Lcác chỉ số 0, 1, 2, 3. Bạn có thể lấy nó làm danh sách các số nguyên hoặc một chuỗi các chữ số. Lưu ý rằng nó có thể trống và nó có thể chứa các bản sao. Độ dài tối đa Llà 5.

Đầu ra

Đầu ra của bạn là mẫu F(L)dưới dạng một chuỗi phân cách dòng mới.

Quy tắc và tính điểm

Bạn có thể viết một chương trình đầy đủ hoặc một chức năng. số byte thấp nhất sẽ thắng và các sơ hở tiêu chuẩn không được phép.

Các trường hợp thử nghiệm

[]
#

[0]
##.
###
.#.

[3]
.#.
###
.##

[2,0]
...#...
...#...
...#...
#######
##.#...
####...
.#.#...

[1,1]
...#.##
...####
...#.#.
#######
...#...
...#...
...#...

[1,2,0]
.......#...#...
.......#...#...
.......#...#...
.......########
.......###.#...
.......#####...
.......#.#.#...
###############
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......

[3,3,1]
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......
###############
.......#...#...
.......#...#...
.......#...#...
.......########
.......#...#.##
.......#...####
.......#...#.#.

[0,1,2,3]
.......#...#...#...............
.......#...#...#...............
.......#...#...#...............
.......#########...............
.......#.#.#...#...............
.......#####...#...............
.......#.###...#...............
################...............
.......#.......#...............
.......#.......#...............
.......#.......#...............
.......#.......#...............
.......#.......#...............
.......#.......#...............
.......#.......#...............
###############################
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............

[0,0,1,2,3]
.......#...#...#...............#...............................
.......#...#...#...............#...............................
.......#...#...#...............#...............................
.......#########...............#...............................
.......#.#.#...#...............#...............................
.......#####...#...............#...............................
.......#.###...#...............#...............................
################...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
################################...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
###############################################################
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
code-golf  ascii-art  fractal 
— Zgarb
nguồn
Trong ví dụ của bạn, tại sao bạn bắt đầu với lưới 1x1 #? L !=[]trong ví dụ đó, vì nó có 1 hoặc nhiều phần tử. Điều này có nghĩa là F (L) luôn luôn là một #lúc đầu?
— R. Kap
2
@ R.Kap Được rồi, ví dụ không rõ ràng lắm. Định nghĩa là đệ quy, vì vậy L = [2,0], bạn chặt đầu và nhìn vào mẫu F([0]), sau đó cắt đầu [0]và nhìn vào mẫu F([]), đó là lưới 1x1 #. Sau đó, bạn sử dụng chỉ mục băm nhỏ 0trên nó để xây dựng mẫu 3x3 và sử dụng chỉ mục băm nhỏ 2trên đó để xây dựng mẫu 7x7. Để trả lời câu hỏi của bạn: có, bạn luôn bắt đầu với lưới 1x1 vì đó là trường hợp cơ bản của đệ quy.
— Zgarb
— Sp3000

Câu trả lời:

6

CJam, 59 47 43 41 40 byte

Cảm ơn Sp3000 vì đã tiết kiệm 1 byte.

Sal~W%{_Bff|a4*I@t2/{zSf*z}:F%F}fI3ff+N*

Kiểm tra nó ở đây.

Giải trình

Hơi lỗi thời. Sẽ sửa sau.

Tất cả sự sắp xếp lại thứ nguyên của danh sách 4D đang khiến tôi choáng váng ...

Mã này thực hiện đặc tả rất đúng theo nghĩa đen, sử dụng thuật toán lặp từ phần ví dụ thay vì định nghĩa đệ quy của nó .. Một mẹo chơi gôn chính là tôi sử dụng khoảng trắng thay vì #trong quá trình tính toán và chỉ thay thế chúng #ở cuối, đơn giản hóa mã ở một nơi và cho phép tôi sử dụng Sthay vì '#hoặc "#"ở một vài nơi.

Sa       e# Push [" "], i.e. a 1x1 grid containing only a space as the
         e# initial fractal.
l~       e# Read and evaluate input.
W%       e# Reverse the list.
{        e# For each list element, assigning the element to variable I...
  _      e#   Duplicate the grid.
  Eff|   e#   Map (OR 14) over each character in the grid, turning spaces into
         e#   periods and leaving periods unchanged.
  a4*    e#   Create an array with four copies of this cleared grid.
  I@t    e#   Replace the Ith element in this list with the previous grid.
  2/     e#   Split this array into a 2x2 grid of subgrids...
         e#   Now it's getting a bit weird... we've got 4 dimensions now, which are:
         e#    - Rows of the 2x2 meta-grid.
         e#    - Cells in each row of the 2x2 meta-grid (i.e. subgrids).
         e#    - Rows of each subgrid.
         e#    - Characters in each row of each subgrid.
  :z     e#   Transpose each outer row, i.e. swap dimensions 2 and 3.
         e#   We've now got in each row of the meta-grid, a list of pairs of
         e#   corresponding rows of the subgrids.
  Sff*   e#   Join those pairs of rows with a single space each. We're now down
         e#   to three dimensions:
         e#    - Rows of the 2x2 meta-grid.
         e#    - Rows of each 1x2 block of the meta-grid.
         e#    - Characters in each row of those blocks.
  :z     e#   Transpose the blocks, i.e. turn the 1x2 blocks into a list of
         e#   columns of their characters.
  z      e#   Transpose the outer grid, i.e. turn it into a list of pairs of
         e#   corresponding columns in the two 1x2 blocks.
  Sf*    e#   Join each pair of columns with a single space. We've now got the
         e#   new grid we're looking for, but it's a list of columns, i.e. transposed.
  z      e#   Fix that by transposing the entire grid once more.
}I
N*       e# Join the rows of the grid with linefeeds.
S'#er    e# Replace all spaces with #.
— Martin Ender
nguồn
3

MATL , 42 41 byte

'.#'4:He!XIiP"Iq@=wX*1X@WZ(l5MY(]3Lt3$)Q)

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

Giải trình

Điều này hoạt động lặp lại bằng cách sử dụng một sản phẩm Kronecker để mở rộng mảng trong mỗi lần lặp. Mảng được xây dựng với 0và 1thay vì .và #, và cuối cùng, chúng được thay thế bằng các ký tự thích hợp.

Sẽ có nhiều lần lặp như kích thước đầu vào. Đầu vào được xử lý từ phải sang trái. Chỉ số lặp bắt đầu lúc 1.

Sử dụng ví dụ trong thử thách, với đầu vào [2,0], mảng được khởi tạo là

1 2
3 4

Điều này tương ứng với 1( ban đầu #) được mở rộng bởi một hàng và một cột, mục đích của nó sẽ rõ ràng sau. Các giá trị trong các cột đó không quan trọng, vì chúng sẽ bị ghi đè; họ cũng có thể là những người:

1 1
1 1

Ở mỗi lần lặp, mảng hiện tại là Kronecker - nhân với một không 2 × 2 - một mảng chứa 1ở vị trí được chỉ định bởi mục nhập hiện tại của đầu vào và 0tại các mục nhập khác. Trong ví dụ tại iteration i = 1, vì mục nhập đầu vào ngoài cùng bên phải là 0, mảng zero-one là

1 0
0 0

và sản phẩm Kronecker của hai mảng này là

 1 1 0 0
 1 1 0 0
 0 0 0 0
 0 0 0 0

Tiếp theo, hàng và cột có chỉ mục 2^iđược điền đầy đủ:

 1 1 0 0
 1 1 1 1
 0 1 0 0
 0 1 0 0

Ba hàng và cột đầu tiên tạo thành kết quả của lần lặp đầu tiên. Như trước đây, có một hàng và cột bổ sung, rất hữu ích cho việc mở rộng mảng trong lần lặp tiếp theo.

Ở lần lặp i = 2, vì giá trị đầu vào hiện tại chứa 2mảng ở trên là Kronecker được nhân với

0 0
1 0

cái nào cho

 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0
 1 1 0 0 0 0 0 0
 1 1 1 1 0 0 0 0
 0 1 0 0 0 0 0 0
 0 1 0 0 0 0 0 0

Điền vào 2^ihàng -thth và cột với những cái cho

 0 0 0 1 0 0 0 0
 0 0 0 1 0 0 0 0
 0 0 0 1 0 0 0 0
 1 1 1 1 1 1 1 1
 1 1 0 1 0 0 0 0
 1 1 1 1 0 0 0 0
 0 1 0 1 0 0 0 0
 0 1 0 1 0 0 0 0

Vì đây là lần lặp cuối cùng, hàng và cột thêm được xóa:

 0 0 0 1 0 0 0
 0 0 0 1 0 0 0
 0 0 0 1 0 0 0
 1 1 1 1 1 1 1
 1 1 0 1 0 0 0
 1 1 1 1 0 0 0
 0 1 0 1 0 0 0

và thay thế nhân vật được thực hiện để tạo ra kết quả cuối cùng:

...#...
...#...
...#...
#######
##.#...
####...
.#.#...

Mô tả chi tiết của mã sau đây:

'.#'      % Push this string. Will be indexed into
4:He!     % Push 2×2 array [1 2; 3 4]
XI        % Copy it into clipboard I
iP        % Input array and reverse it
"         % For each entry of the reversed input
  I       %   Push [1 2; 3 4] from clipboard I
  q       %   Subtract 1 to yield [0 1; 2 3]
  @=      %   Compare with current entry of the input. Gives 2×2 array
          %   with an entry equal to `1` and the rest `0`
  wX*     %   Swap. Kronecker product
  1       %   Push 1
  X@      %   Push iteration index, i
  W       %   Compute 2^i
  Z(      %   Write 1 into column 2^i
  l       %   Push 1
  5M      %   Push 2^i again
  Y(      %   Write 1 into row 2^i
]         % End for each
3Lt       % Push [1, -1j] (corresponding to index 1:end-1) twice
3$)       % Apply index. Removes last row and column
Q         % Add 1. Gives an array of values 1 and 2
)         % Index into initial string
— Luis Mendo
nguồn
2

Haskell, 123 122 byte

unlines.foldr(#)["#"]
n#p=zipWith(++)(r++h:t)$('#':)<$>u++h:s where b='.'<$p<$p;h='#'<$p;(r:s:t:u:_)=drop n$cycle[p,b,b,b]

Ví dụ sử dụng:

*Main> putStr $ (unlines.foldr(#)["#"]) [2,3,1]
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......
###############
...#...#.......
...#...#.......
...#...#.......
########.......
...#.###.......
...#####.......
...#.#.#.......

Làm thế nào nó hoạt động:

                ["#"]      -- starting with "#" 
        foldr(#)           -- fold the function # from the right into the input
unlines                    -- and join the result with newlines

n#p=                       -- helper function #
                           -- n: next index, p: fractal so far
    zipWith(++)            -- join the left and right part elementwise
       (r++h:t)            -- left part
       ('#':) <$> u++h:s   -- right part (prepend '#' to each line for vertical
                           -- separator

                           -- helper
b='.'<$p<$p                -- b is a blank square of the same size as p
h='#'<$p                   -- h is a line of '#' of the same length as p
(r:s:t:u:_)=               -- drop the first n elements of the infinite
    drop n$cycle[p,b,b,b]  --   list [p,b,b,b,p,b,b,b,p,b,b,b,...] and
                           --   assign the next 4 element to r,s,t,u.
                           --   As r,s,t,u are always inserted at the
                           --   same position in the fractal, we get the
                           --   variants by assigning different values.
— nimi
nguồn
1

JavaScript (ES6), 171 152 byte

([d,...a],h=`#`,r=`replace`)=>d<4?(s=f(a)[r](/.+/g,s=>(t=s[r](/./g,`.`),d&1?t+h+s:s+h+t)),t=s[r](/.+/g,w=t+h+t),w=`
${w[r](/./g,h)}
`,d&2?t+w+s:s+w+t):h

Thực hiện kết quả của cuộc gọi đệ quy, sau đó thay thế từng dòng bằng chính nó cộng với một hàm băm cộng với một chuỗi các chấm có cùng độ dài, theo thứ tự ngược lại nếu cần, sau đó từ kết quả một phần đó tạo ra một chuỗi các dấu chấm trừ các dòng mới và cột trung tâm băm, và cũng là một chuỗi băm với các dòng mới xung quanh, sau đó nối ba chuỗi đó lại với nhau theo thứ tự thích hợp.

— Neil
nguồn
1

Ruby, 143 134 byte

Một chức năng ẩn danh.

1 byte được lưu bằng cách sắp xếp lại dòng đầu tiên. 6 byte được lưu bằng cách thay đổi cách tăng z từ công thức sang bảng. 2 byte được lưu bằng cách loại bỏ biến w.

->a{r=-1+u=2<<a.size
s=(?.*r+$/)*r
a<<0
z=r*u/2-1
a.each{|i|r/=2
(-r..r).each{|j|s[z+j]=s[z+j*u]=?#}
z+=-r/2*[u+1,u-1,1-u,-u-1][i]}
s}

Ungolfed trong chương trình thử nghiệm

f=->a{
  r=w=(u=2<<a.size)-1        #w=length of line excluding newline, u=length of line including newline.
  s=(?.*w+$/)*w              #initialize string s with w rows of w dots terminated by newlines.
  z=w*u/2-1                  #z is the centre of the fractal
  a<<0                       #add a dummy value to the end of a
  a.each{|i|                 #for each element in a
    r/=2                     #r is the radius of the current iteration: ....15,7,3,1
    (-r..r).each{|j|         #for j=-r to r
      s[z+j]=s[z+j*u]=?#     #overwrite . with #, forming horizontal and vertical lines
    }
    z+=-r/2*(u+1)+           #move z to centre of upper left quarter (where it should be if i=0)
      i%2*(q=r+1)+           #move across if i=1,3
      i/2%2*q*u              #and down if i=2,3  
  }
s}                           #return string

puts $/,f[[]]

puts $/,f[[0]]

puts $/,f[[3]]

puts $/,f[[2,0]]

puts $/,f[[1,1]]

puts $/,f[[1,2,0]]

puts $/,f[[3,3,1]]

puts $/,f[[0,1,2,3]]

puts $/,f[[0,0,1,2,3]]
— Cấp sông St
nguồn
0

Ruby, 150 byte

Chức năng ẩn danh. Sử dụng một cuộc gọi đệ quy để xây dựng một danh sách các chuỗi, một chuỗi trên mỗi dòng, sau đó kết hợp tất cả chúng lại với nhau ở cuối.

->i{f=->l{s=2**l.size-1;g=[[?.*s]*s]*4;m=->x,y{x.zip(y).map{|a,b|a+?#+b}}
s<1?[?#]:(g[l.shift]=f[l];m[*g[0,2]]+[?#*(2*s+1)]+m[*g[2,2]])}
f[i].join"
"}
— Giá trị mực
nguồn
0

Python 3.5, 1151 byte:

Không có nhiều mã golf, nhưng oh tốt. Sẽ cố gắng cắt tỉa nó nhiều hơn theo thời gian nơi tôi có thể.

def x(s):
 y=[''];l=['#'];k=[' ']
 for z in s[::-1]:y.append(z)
 y=y[::-1]
 for h in range(len(y)):
  if y[-1]!='':u=(int(y.pop())&3)
  else:u=y.pop()
  if len(l)<2:k.append(u);p=((2**(len(k)-1))-1);l.append((('.'*p+'#'+'.'*p+'\n')*p)+'#'*((p*2)+1)+'\n'+(('.'*p+'#'+'.'*p+'\n')*p))
  else:
   if len(l)>2:del l[0]
   p=((2**(len(k)-1))-1);a=[[_+i for i in range(p)]for _ in range(len(l[1]))if _%((p*2)+2)==0 and _!=(((p*2)+2)*(p))];b=[[_+i for i in range(p)]for _ in range(len(l[1]))if _%(int(((p*2)+2)/2))==0 and _!=(int(((p*2)+2)/2)*((p)*2))and _ not in[g for i in a for g in i]];W=[g for i in a[:len(a)-(int(len(a)/2)):1]for g in i];B=[g for i in b[:len(b)-(int(len(b)/2)):1]for g in i];C=[g for i in a[len(a)-(int(len(a)/2)):len(a):1]for g in i];T=[g for i in b[len(b)-(int(len(b)/2)):len(b):1]for g in i];f=list(l[1])
   for i in list(''.join(l[0].split())):
    if u==0:f[W[0]]=i;del W[0]
    elif u==1:f[B[0]]=i;del B[0]
    elif u==2:f[C[0]]=i;del C[0]
    elif u==3:f[T[0]]=i;del T[0]
   del l[0];k.append(u);p=((2**(len(k)-1))-1);l.append(''.join(f));l.append((('.'*p+'#'+'.'*p+'\n')*p)+'#'*((p*2)+1)+'\n'+(('.'*p+'#'+'.'*p+'\n')*p))
 print(l[-2])

Một cách khá ngây thơ để làm điều này, nhưng, dù sao, hiện đang hoạt động hoàn hảo và, như bạn có thể thấy, không sử dụng các mô-đun / thư viện bên ngoài. Thêm vào đó, nó có thể mất trên đường hơn 5 mục trong danh sách được cung cấp smà không bị mất bất kỳ chính xác (có nghĩa là, nếu phần cứng của bạn có thể xử lý nó). Nó đáp ứng tất cả các yêu cầu và tôi không thể hạnh phúc hơn với những gì mình nhận được. :)

Giờ đây nó cũng có thể không chỉ chấp nhận bất kỳ số nào trong phạm vi 0=>3như bất kỳ giá trị nào, mà bất kỳ số , khoảng thời gian nào, nhờ &toán tử bitwise! Bạn có thể đọc thêm về họ ở đây . Bây giờ, ví dụ, [4,4,1,2,3]như danh sách đầu vào giống như [0,0,1,2,3].

Lưu ý: Đầu vào phải được cung cấp dưới dạng danh sách

Ung dung với lời giải thích:

def x(s):
 # Create 3 lists:
 # `y` is for the values of `s` (the list provided) and an empty element for the 
 # first pattern
 # `l` is reserved for the pattersn created through each item in list `y`
 # `k` is created for the value of `p` which is the main value through which the 
 # pattern is created.
 y=[''];l=['#'];k=[' ']
 # Reverse s, and then add each element from `s` to `y` 
 # (in addition to the empty element) 
 for z in s[::-1]:
     y.append(z)
 # `y` should now equal the list created, but reversed
 # If not reversed, then, if, for instance, the input is `0,1,2` and list `y` 
 # therefore contains `'',2,1,0`, the empty element will be called at the end, 
 # which is NOT what we want.
 y=y[::-1]
 # The main loop; will be iterated through the length of `y` number of times
 for h in range(len(y)):
  # Here is where each element from the end of `y` is recieved as `u` for 
  # use in the pattern in each iteration.
  # As you can also see, a bitwise operator (`&`) is used here so that 
  # ALL numbers can be accepted. Not just those in the range `0-4`.     
  # However, that will happen only if the value of y[-1] (the last elment in y) is 
  # NOT ''.
  if y[-1]!='':
      u=(int(y.pop())&3)
  else:
      u=y.pop()
  # If the length of list `l` is less than 2 
  # (which means it only contains `#`), then do the following:
  if len(l)<2:
      # Append `u` to `k`
      k.append(u)
      # Use the length of `k` as `n` in the operation `(2^(n-1)-1)` to get the 
      # length of the dot filled part of the new pattern.
      p=((2**(len(k)-1))-1)
      # Add that pattern to the list (currently empty, 
      # i.e. containing no other pattern in any other quadrant)
      l.append((('.'*p+'#'+'.'*p+'\n')*p)+'#'*((p*2)+1)+'\n'+(('.'*p+'#'+'.'*p+'\n')*p))
  # Now, if the length of l is >=2, do the following:
  else:
   # If the length of l is >2, then delete the first element in list `l` 
   # (this will happen only once, when the `#` is still the first element)
   if len(l)>2:
       del l[0]
   # Again, use the length of `k` as `n` in the operation `(2^(n-1)-1)`
   # to get the length of the dot filled part of the pattern.
   p=((2**(len(k)-1))-1)
   # Create a list with all the index values of all the dot elements on the left hand 
   # side of the grid l[-1], and the index value + i where i is every integer in 
   # the range `0-p` (this way, it will create lists within a list, each 
   # which contain `p` number of integers, which are all indexes of all the dots on 
   # the very left side of the grid) 
   a=[[_+i for i in range(p)]for _ in range(len(l[1]))if _%((p
      *2)+2)==0 and _!=(((p*2)+2)*(p))]
   # Create another list with all the index values of the dots using the same 
   # strategy as above, but this time, those in the right half of the grid. 
   b=[[_+i for i in range(p)]for _ in range(len(l[1]))if _%(int(((p*2)+2)/2))==0 
      and _!=(int(((p*2)+2)/2)*((p)*2))and _ not in[g for i in a for g in i]]
   # Create 4 lists, each containing index values specific to each of the 
   # 4 quadrants of the grid.
   # W is the list, based on A, containing all the indexes for the 1st quadrant of 
   # the grid in l[-1] containing dots (index 0 in the grid)
   W=[g for i in a[:len(a)-(int(len(a)/2)):1]for g in i]
   # B is the list, this time based on b, containing all indexes for the 2nd 
   # dot-filled quadrant of the grid l[-1] (index 1 in the grid)
   B=[g for i in b[:len(b)-(int(len(b)/2)):1]for g in i]
   # C is the list, also, like W, based on a, containg all the index values for 
   # the 3rd dot-filled quadrant of the grid in l[-1] (index 2 in the grid)
   C=[g for i in a[len(a)-(int(len(a)/2)):len(a):1]for g in i]
   # T is the final list, which, also like B, is based on b, and contains all the 
   # index values for the final (4th) dot-filled quadrant of the grid in l[-1] 
   T=[g for i in b[len(b)-(int(len(b)/2)):len(b):1]for g in i];f=list(l[1])
   # Finally, in this `for` loop, utilize all the above lists to create the new 
   # pattern, using the last two elements in list `l`, where each character of grid 
   # l[-2] (the second to last element) is added to the correct index of grid l[-1] 
   # based on the value of `u`
   for i in list(''.join(l[0].split())):
    if u==0:
        f[W[0]]=i
        del W[0]
    elif u==1:
        f[B[0]]=i
        del B[0]
    elif u==2:
        f[C[0]]=i
        del C[0]
    elif u==3:
        f[T[0]]=i
        del T[0]
   # Delete the very first element of `l`, as it is now not needed anymore
   del l[0]
   # Append `u` to list`k` at the end of the loop this time
   k.append(u)
   # Update the value of `p` with the new value of length(k)
   p=((2**(len(k)-1))-1)
   # Append the new patter created from the for-loop above to list `l`
   l.append(''.join(f))
   # Append a new, empty pattern to list `l` for use in the next iteration
   l.append((('.'*p+'#'+'.'*p+'\n')*p)+'#'*((p*2)+1)+'\n'+(('.'*p+'#'+'.'*p+'\n')*p))
 # When the above main loop is all finished, print out the second-to-last elment in 
 # list `l` as the very last element is the new, empty grid created just in case 
 # there is another iteration
 print(l[-2])

Giải thích trực quan rộng hơn & hấp dẫn hơn nhiều:

Đối với một lời giải thích trực quan rộng hơn và hấp dẫn hơn nhiều, hãy xem xét lần thứ hai đi qua phần "chính" trong đoạn mã trên, trong đó danh sách đầu vào là [0,2]. Trong trường hợp này, các thành phần trong danh sách "chính" lsẽ là:

.#.
###
##.

và 

...#...
...#...
...#...
#######
...#...
...#...
...#...

và danh sách ysẽ chỉ chứa 0. Tận dụng cách lập chỉ mục của phần tử lưới của Python l[-1], chúng ta có thể gắn nhãn cho các phần tử bên trái của lưới như sau:

 0 ...#...\n 7        
 8 ...#...\n 15
16 ...#...\n 23
   #######\n <- Ignore this as it is nothing but `#`s and a new line
32 ...#...\n 39
40 ...#...\n 47
48 ...#...\n 55

Bạn thấy mẫu nào? Mỗi chỉ số ở bên trái của lưới là bội số của 8 và vì sử dụng phương trình 2^(n-1)-1mang lại độ dài của từng đoạn của các chấm trong lưới, chúng ta có thể làm ((2^(n-1)-1)*2)+2để tìm toàn bộ chiều dài của cạnh trên cùng của lưới (+2 để bao gồm giữa #và s \nở cuối). Chúng ta có thể sử dụng phương trình đó, chúng ta sẽ gọi iđể tìm các giá trị chỉ mục của từng phần tử ở bên trái của lưới có kích thước bất kỳ bằng cách tạo danh sách và nối thêm vào danh sách mọi số nguyên mà chúng ta sẽ gọi _, trong phạm vi 0=>length of grid l[-1], sao cho mục đó là bội số của iAND, cũng như vậy _KHÔNG bằng nhau i*(2^(n-1)-1), do đó chúng ta có thể loại trừ phân khúc giữa của#s tách nửa trên và nửa dưới. Nhưng chúng tôi muốn TẤT CẢ các yếu tố chấm từ bên trái, và không chỉ các yếu tố ở phía bên trái. Chà, có một cách khắc phục, và đó chỉ đơn giản là thêm vào danh sách một danh sách chứa i+hh trong đó mỗi số nguyên trong phạm vi 0=>2^(n-1)mỗi lần một giá trị từ phạm vi 0=>length of grid l[-1]được thêm vào danh sách, để mỗi lần, sẽ có số lượng giá trị được thêm vào danh sách là độ dài của một góc phần tư. Và đó là danh sách a.

Nhưng bây giờ, làm thế nào về các chấm trên một nửa bên phải? Chà, chúng ta hãy nhìn vào việc lập chỉ mục theo một cách khác:

   0 ...# 4  ...\n 7        
   8 ...# 12 ...\n 15
  16 ...# 20 ...\n 23
     #######\n <- Ignore this as it is nothing but `#`s and a new line
  32 ...# 36 ...\n 39
  40 ...# 44 ...\n 47
  48 ...# 52 ...\n 55

          ^
          | 

          These are the values we are looking at now

Như bạn có thể thấy, các giá trị ở giữa là những giá trị mà chúng ta cần, vì chúng là khởi đầu của chỉ mục của mọi phân đoạn dấu chấm ở phía bên phải của lưới. Bây giờ, mô hình ở đây là gì? Chà, nếu nó chưa đủ rõ ràng, thì bây giờ các giá trị trung bình là bội số của i/2! Với thông tin đó, giờ đây chúng ta có thể tạo một danh sách khác, btrong đó bội số i/2được thêm vào từ phạm vi 0=>length of grid l[-1]sao cho mỗi số nguyên từ phạm vi đó, mà chúng ta sẽ gọi lại _, KHÔNG bằng (i/2)*(p*2)để loại trừ dòng #s tách ra trên cùng và nửa dưới, VÀ sao cho _ KHÔNG có trong danh sách a, vì chúng ta không thực sự cần 8,16,32, v.v. trong danh sáchb. Và bây giờ, một lần nữa, chúng tôi không chỉ muốn những chỉ số cụ thể đó. Chúng tôi muốn TẤT CẢ các ký tự dấu chấm ở phía bên phải của lưới. Vâng, giống như chúng ta đã làm trong danh sách a, ở đây chúng ta cũng có thể thêm vào danh sách danh bsách _+hnơi hmỗi số nguyên trong phạm vi 0=>2^(n-1).

Bây giờ, chúng tôi có cả danh sách avà bđóng gói và sẵn sàng để đi. Làm thế nào chúng ta sẽ mang những thứ này lại với nhau bây giờ? Đây là nơi mà danh sách W, T, G, và Cđi vào. Họ sẽ tổ chức các chỉ số cho mỗi góc phần tư cụ thể của dấu chấm trong lưới l[-1]. Chẳng hạn, chúng ta hãy dự trữ danh sách Wlàm danh sách cho tất cả các chỉ mục bằng góc phần tư 1 (chỉ số 0) của lưới. Trong danh sách này, sau đó chúng tôi sẽ thêm các 2^(n-1)danh sách đầu tiên từ danh sách a, vì danh sách achứa tất cả các chỉ mục cho các dấu chấm ở nửa bên trái của lưới và sau đó phân chia tất cả chúng để Wbây giờ có chứa (2^(n-1))*(2^(n-1))các phần tử. Chúng tôi sẽ làm tương tự cho danh sách T, nhưng với sự khác biệt Tsẽ chứa các yếu tố từ danh sách b, vìTđược dành riêng cho góc phần tư 2 (chỉ số 1). Danh sách Gsẽ giống như danh sách W, ngoại trừ nó sẽ chứa phần còn lại của các phần tử từ danh sách avà danh sách Cgiống như danh sách T, ngoại trừ bây giờ nó chứa phần còn lại của các phần tử từ danh sách b. Và, đó là nó! Bây giờ chúng ta có các giá trị chỉ mục cho mỗi góc phần tư chứa các chấm trong lưới, tất cả được chia thành bốn danh sách tương ứng với mỗi góc phần tư. Bây giờ chúng ta có thể sử dụng 4 danh sách này (W, T, G, C) để cho chương trình biết những ký tự nào cần thay thế trong lưới l[-1]với mỗi ký tự từ lưới l[0], là thành phần đầu tiên của danh sách l. Vì giá trị 0ở đây, nó sẽ thay thế tất cả các dấu chấm trong góc phần tư thứ nhất (chỉ số 0) bằng l[0]danh sách sử dụng lướiW.

Do đó, cuối cùng chúng ta cũng có những điều sau đây:

.#.#...
####...
##.#...
#######
...#...
...#...
...#...

Phù! Quá trình dài, phải không? Tuy nhiên, nó hoạt động hoàn hảo, và một lần nữa, tôi không thể hạnh phúc hơn. :)

— R. Kap
nguồn
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookie và Chính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.