บทนำ

ในการท้าทายนี้เมทริกซ์ 2 × 2 จะถูกจัดทำดัชนีดังนี้:

0 1
2 3

เรากำหนดครอบครัวของเศษส่วนเหมือนรูปแบบF(L)ที่Lเป็น length- nรายการของดัชนีเหล่านี้และมีขนาดF(L)2n-1 × 2n-1

• หากL == []แล้วคือรูปแบบที่F(L) 1 × 1#

• ถ้าเป็นเช่นL != []นั้นF(L)จะสร้างขึ้นดังนี้ อนุญาตPเป็นรูปแบบที่ได้รับจากการLลบองค์ประกอบแรก เวลาสี่กริดขนาดเต็มไปด้วยระยะเวลาและแทนที่ตารางดัชนีโดยมีรูปแบบ จากนั้นกาวกริดเข้าด้วยกันโดยใช้หนึ่งชั้นของแฮชระหว่างพวกเขา นี่คือไดอะแกรมสำหรับสี่กรณี: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]
  ...#...  ...#...     #...  ...#   
  

ตัวอย่าง

L = [2,0]พิจารณาการป้อนข้อมูล เราเริ่มต้นด้วยตาราง 1 × 1 #และสำรวจLจากด้านขวา องค์ประกอบที่ถูกต้องที่สุดคือ0เราจึงเอาตาราง 1 × 1 จำนวนสี่ชุด.มาแทนที่อันแรกด้วย#และทากาวเข้าด้วยกันด้วยแฮช ผลลัพธ์นี้ในตาราง 3 × 3

##.
###
.#.

องค์ประกอบถัดไปคือ2เราจึงเอาตาราง 3 × 3 ของ.s ไปสี่ชุดแล้วแทนที่อันที่สามด้วยตารางด้านบน สี่กริดคือ

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

และติดกาวพวกเขาพร้อมกับ#ผลลัพธ์ในตาราง 7 × 7

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

นี่คือผลลัพธ์สุดท้ายของเรา

อินพุต

ข้อมูลของคุณมีรายชื่อของดัชนีL 0, 1, 2, 3คุณสามารถใช้มันเป็นรายการของจำนวนเต็มหรือสตริงของตัวเลข โปรดทราบว่ามันอาจว่างเปล่าและอาจมีรายการที่ซ้ำกัน ความยาวของLไม่เกิน 5

เอาท์พุต

เอาต์พุตของคุณเป็นรูปแบบF(L)เป็นสตริงที่คั่นด้วยบรรทัดใหม่

กฎและการให้คะแนน

คุณสามารถเขียนโปรแกรมเต็มรูปแบบหรือฟังก์ชั่น จำนวนไบต์ต่ำสุดที่ชนะและช่องโหว่มาตรฐานไม่ได้รับอนุญาต

กรณีทดสอบ

[]
#

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

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

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

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

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

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

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

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

CJam, 59 47 43 41 40 ไบต์

ขอบคุณ Sp3000 สำหรับการบันทึก 1 ไบต์

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

ทดสอบที่นี่

คำอธิบาย

ล้าสมัยเล็กน้อย จะแก้ไขในภายหลัง

การจัดลำดับมิติใหม่ของรายการ 4D ทั้งหมดทำให้ฉันมึนงง ...

รหัสนี้ใช้สเปคอย่างแท้จริงโดยใช้อัลกอริทึมซ้ำจากส่วนตัวอย่างแทนคำจำกัดความซ้ำ .. เคล็ดลับการเล่นกอล์ฟที่สำคัญอย่างหนึ่งคือฉันใช้ช่องว่างแทน#ในระหว่างการคำนวณและแทนที่ด้วย#ตอนท้ายซึ่งลดความซับซ้อนลง รหัสในที่เดียวและอนุญาตให้ฉันใช้Sแทน'#หรือ"#"ในหลาย ๆ

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 #.

MATL , 42 41 ไบต์

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

ลองออนไลน์!

คำอธิบาย

การทำงานนี้ซ้ำ ๆ กันโดยใช้ผลิตภัณฑ์ Kroneckerเพื่อขยายอาร์เรย์ในการวนซ้ำแต่ละครั้ง อาร์เรย์ถูกสร้างขึ้นด้วย0และ1แทนที่.และ#และในตอนท้ายจะถูกแทนที่ด้วยอักขระที่เหมาะสม

จะมีการทำซ้ำมากเท่ากับขนาดอินพุต อินพุตถูกประมวลผลจากขวาไปซ้าย 1ย้ำดัชนีเริ่มต้นที่

ใช้ตัวอย่างในการท้าทายด้วยอินพุต[2,0]อาร์เรย์จะถูกเริ่มต้นให้เป็น

1 2
3 4

สิ่งนี้สอดคล้องกับ initial 1( #) ที่ขยายโดยหนึ่งแถวและหนึ่งคอลัมน์ซึ่งวัตถุประสงค์จะชัดเจนในภายหลัง ค่าในคอลัมน์เหล่านั้นไม่สำคัญเนื่องจากจะมีการเขียนทับ พวกเขาสามารถเป็นคนอย่างเท่าเทียมกัน:

1 1
1 1

ในการวนซ้ำแต่ละครั้งอาร์เรย์ที่มีอยู่คือ Kronecker คูณด้วยอาร์เรย์ 2 × 2 zero-one ที่มี1ณ ตำแหน่งที่ระบุโดยรายการปัจจุบันของอินพุตและ0ที่รายการอื่น ๆ ในตัวอย่างที่การวนซ้ำi = 1 เนื่องจากรายการอินพุตขวาสุดคือ0อาร์เรย์ zero-one

1 0
0 0

และผลิตภัณฑ์ Kronecker ของสองอาร์เรย์นี้คือ

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

ถัดไปแถวและคอลัมน์ที่มีดัชนี2^iจะเต็มไปด้วยรายการ:

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

สามแถวและคอลัมน์แรกประกอบด้วยผลลัพธ์ของการวนซ้ำแรก ก่อนหน้านี้มีแถวและคอลัมน์พิเศษซึ่งมีประโยชน์สำหรับการขยายอาร์เรย์ในการทำซ้ำครั้งถัดไป

ที่วนซ้ำi = 2 เนื่องจากค่าอินพุตปัจจุบันมี2อาร์เรย์ด้านบนคือ Kronecker- คูณด้วย

0 0
1 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 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

เติม2^i-th แถวและคอลัมน์ด้วยการให้

 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

เนื่องจากนี่เป็นการทำซ้ำครั้งล่าสุดแถวและคอลัมน์เพิ่มเติมจึงถูกลบ:

 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

และการเปลี่ยนตัวอักขระทำเพื่อให้ได้ผลลัพธ์สุดท้าย:

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

คำอธิบายรายละเอียดของรหัสดังต่อไปนี้:

'.#'      % 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

Haskell, 123 122 ไบต์

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]

ตัวอย่างการใช้งาน:

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

มันทำงานอย่างไร:

                ["#"]      -- 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.

JavaScript (ES6), 171 152 ไบต์

([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

รับผลลัพธ์ของการโทรซ้ำจากนั้นแทนที่แต่ละบรรทัดด้วยตัวเองบวกกับแฮชบวกสตริงจุดที่มีความยาวเท่ากันเรียงลำดับย้อนกลับหากจำเป็นจากนั้นผลลัพธ์บางส่วนจะสร้างสตริงจุดยกเว้นบรรทัดใหม่และคอลัมน์กลาง ของแฮ็ชและสตริงของแฮชที่มีการขึ้นบรรทัดใหม่ที่ล้อมรอบจากนั้นรวมสามสตริงเข้าด้วยกันตามลำดับที่เหมาะสม

Ruby, 143 134 ไบต์

ฟังก์ชั่นที่ไม่ระบุชื่อ

1 ไบต์บันทึกโดยการจัดเรียงบรรทัดแรกใหม่ บันทึก 6 ไบต์ด้วยการเปลี่ยนวิธีการเพิ่มค่าจากสูตรเป็นตาราง 2 ไบต์ที่บันทึกไว้โดยการกำจัด wvarable

->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 ในโปรแกรมทดสอบ

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

ทับทิม 150 ไบต์

ฟังก์ชั่นไม่ระบุชื่อ ใช้การเรียกซ้ำเพื่อสร้างรายการของสตริงหนึ่งสตริงต่อบรรทัดจากนั้นรวมพวกเขาทั้งหมดเข้าด้วยกันในตอนท้าย

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

Python 3.5, 1151 ไบต์:

รหัสไม่มากนักกอล์ฟ แต่ก็ดี จะพยายามตัดให้มันมากขึ้นตามเวลาที่ฉันสามารถทำได้

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

วิธีที่ไร้เดียงสาในการทำสิ่งนี้ แต่กระนั้นก็ยังทำงานได้อย่างสมบูรณ์และอย่างที่คุณเห็นไม่มีการใช้โมดูล / ไลบรารีภายนอก นอกจากนี้ยังสามารถใช้ในทางที่เกินกว่า 5 รายการในรายการที่มีให้sโดยไม่สูญเสียความถูกต้องใด ๆ (นั่นคือถ้าฮาร์ดแวร์ของคุณสามารถจัดการกับมัน) มันเป็นไปตามข้อกำหนดทั้งหมดและฉันไม่สามารถมีความสุขกับสิ่งที่ฉันได้รับ :)

นอกจากนี้ยังสามารถรับได้ไม่เพียง แต่ตัวเลขใด ๆ ที่อยู่ในช่วง0=>3เป็นค่าใด ๆแต่ยังมีจำนวนระยะเวลาขอบคุณ&ผู้ประกอบการระดับบิต! คุณสามารถอ่านเพิ่มเติมเกี่ยวกับพวกเขาที่นี่ ตอนนี้เช่น[4,4,1,2,3]เป็นรายการการป้อนข้อมูลที่เป็นเดียวกันเป็น[0,0,1,2,3]เป็น

หมายเหตุ: ต้องป้อนข้อมูลเป็นรายการ

Ungolfed พร้อมคำอธิบาย:

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

คำอธิบายที่กว้างขึ้นและดึงดูดสายตามากขึ้น:

สำหรับคำอธิบายที่กว้างและไกลน่าสนใจมากขึ้นสายตาพิจารณาเป็นครั้งที่สองที่จะผ่าน "หลัก" -loop [0,2]ในโค้ดข้างต้นซึ่งในรายการเข้าเป็น ในกรณีนี้องค์ประกอบในรายการ "main" lจะเป็น:

.#.
###
##.

และ

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

และรายการเดียวที่จะมีy 0การใช้ประโยชน์จากวิธีการจัดทำดัชนีองค์ประกอบสุดท้ายของ Python l[-1]เราสามารถติดป้ายองค์ประกอบที่ยังเหลืออยู่ของกริดเช่น:

 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

คุณเห็นรูปแบบอะไร ดัชนีทุกตัวที่อยู่ทางด้านซ้ายของกริดนั้นเป็นผลคูณของ 8 และเนื่องจากการใช้สมการ2^(n-1)-1ทำให้ความยาวของจุดแต่ละจุดในกริดเราสามารถทำได้((2^(n-1)-1)*2)+2เพื่อหาความยาวของขอบด้านบนของกริดโดยรวม (+2 เพื่อรวมเครื่องหมายกลาง#และ\nท้าย) เราสามารถใช้สมการที่ซึ่งเราจะโทรiไปหาค่าดัชนีของแต่ละองค์ประกอบทางด้านซ้ายของตารางที่มีขนาดใดโดยการสร้างรายการและผนวกกับรายการทุกจำนวนเต็มซึ่งเราจะเรียก_ในช่วง0=>length of grid l[-1], เช่นว่ารายการนั้นเป็นผลคูณของiและก็เช่นกันที่_ไม่เท่ากันi*(2^(n-1)-1)เพื่อให้เราสามารถยกเว้นส่วนตรงกลางของ#แยกครึ่งบนจากครึ่งล่าง แต่เราต้องการองค์ประกอบจุดทั้งหมดจากด้านซ้ายและไม่เพียง แต่องค์ประกอบทางด้านซ้าย ทีนี้ก็มีการแก้ไขและนั่นก็คือการผนวกรายการที่ประกอบด้วยi+hh โดยที่ h คือจำนวนเต็มทุกค่าในช่วง0=>2^(n-1)แต่ละครั้งที่มีการเพิ่มค่าจากช่วง0=>length of grid l[-1]ลงในรายการดังนั้นแต่ละครั้งจะมี จำนวนค่าที่เพิ่มจำนวนมากเข้าไปในรายการตามความยาวของหนึ่งจุดของจุด aและนั่นคือรายการ

แต่ตอนนี้แล้วจุดต่างๆในครึ่งขวาล่ะ? เรามาดูการจัดทำดัชนีในวิธีอื่น:

   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

อย่างที่คุณเห็นค่าตอนนี้อยู่ตรงกลางคือค่าที่เราต้องการเนื่องจากเป็นจุดเริ่มต้นของดัชนีของทุกส่วนของจุดทางด้านขวาของตาราง รูปแบบที่นี่คืออะไร ถ้ายังไม่ชัดเจนพอตอนนี้ค่ากลางคือทวีคูณทั้งหมดi/2! ด้วยข้อมูลนั้นตอนนี้เราสามารถสร้างรายการใหม่bซึ่งการi/2เพิ่มทวีคูณของจากช่วง0=>length of grid l[-1]ที่แต่ละจำนวนเต็มจากช่วงนั้นซึ่งเราจะเรียกอีกครั้ง_ไม่เท่ากับ(i/2)*(p*2)การแยกบรรทัดของ#การแยกด้านบนและ ครึ่งล่างและ _ ที่ไม่ได้อยู่ในรายการ a เนื่องจากเราไม่ต้องการ 8,16,32 ฯลฯ ในรายการb. และตอนนี้อีกครั้งเราไม่เพียงต้องการดัชนีเฉพาะเหล่านั้น เราต้องการอักขระจุดทั้งหมดที่ด้านขวาของกริด ดีก็เหมือนที่เราทำในรายการaที่นี่เรายังสามารถเพิ่มรายชื่อbรายชื่อ_+hที่เป็นจำนวนเต็มในช่วงแต่ละh0=>2^(n-1)

ตอนนี้เรามีทั้งรายการaและbบรรจุแล้วพร้อมที่จะไป เราจะนำสิ่งเหล่านี้มารวมกันได้อย่างไร? นี่คือที่รายการW, T, GและCมาใน. l[-1]พวกเขาจะถือดัชนีแต่ละเฉพาะวอดจุดในตาราง ตัวอย่างเช่นให้เราจองรายการWเป็นรายการสำหรับดัชนีทั้งหมดเท่ากับจตุภาค 1 (ดัชนี 0) ของตาราง ในรายการนี้เราจะเพิ่ม2^(n-1)รายการแรกจากรายการaเนื่องจากรายการaมีดัชนีทั้งหมดสำหรับจุดในครึ่งซ้ายของตารางแล้วแยกพวกมันทั้งหมดออกเพื่อให้Wมี(2^(n-1))*(2^(n-1))องค์ประกอบอยู่ในขณะนี้ เราจะทำเช่นเดียวกันสำหรับรายการTแต่มีความแตกต่างที่Tจะมีองค์ประกอบจากรายการbตั้งแต่Tสงวนไว้สำหรับ Quadrant 2 (ดัชนี 1) รายการGจะเป็นเช่นเดียวกับรายการWยกเว้นมันจะมีส่วนที่เหลือขององค์ประกอบจากรายการaและรายการCเป็นเช่นเดียวกับรายการยกเว้นได้ในขณะนี้มีส่วนที่เหลือขององค์ประกอบจากรายการT bและนั่นคือมัน! ตอนนี้เรามีค่าดัชนีสำหรับทุกควอแดรนท์ที่มีจุดในกริดทั้งหมดแบ่งออกเป็นสี่รายการที่สอดคล้องกับควอดเรนท์แต่ละอัน ตอนนี้เราสามารถใช้เหล่านี้ 4 รายการ (W, T, G, C) ที่จะบอกโปรแกรมที่ตัวละครมันควรเปลี่ยนในตารางl[-1]กับตัวละครแต่ละตัวจากตารางซึ่งเป็นองค์ประกอบแรกสุดของรายการl[0] lเนื่องจากค่าอยู่0ที่นี่มันจะแทนที่จุดทั้งหมดในจตุภาคแรก (ดัชนี 0) ด้วยl[0]รายการการใช้กริดW.

ดังนั้นในที่สุดเราจึงมีสิ่งต่อไปนี้:

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

ต๊าย! กระบวนการที่ยาวนานมันใช่ไหม? อย่างไรก็ตามมันทำงานได้อย่างสมบูรณ์และอีกครั้งฉันไม่สามารถมีความสุข :)