소개

이 과제에서 2 × 2 행렬은 다음과 같이 색인됩니다.

0 1
2 3

우리의 가족 정의 프랙탈 같은 패턴 F(L), 어디 L길이 - 인 n이 인덱스의 목록과 F(L)크기가 .2ⁿ-1 × 2ⁿ-1

경우 L == [], 다음 F(L)1 × 1 패턴이다 #.
경우 L != [], 다음 F(L)다음과 같이 구성되어있다. 첫 번째 요소를 제거한 상태 P에서 얻은 패턴을 보자 L. 마침표로 채워진 네 개의 격자 크기 를 취하고 패턴으로 색인 된 격자를 대체하십시오 . 그런 다음 하나의 해시 레이어를 사용하여 그리드를 서로 붙 입니다. 다음은 네 가지 경우에 대한 다이어그램입니다.2^n-1-1 × 2^n-1-1.L[0]P#
```
L[0]==0  L[0]==1  L[0]==2  L[0]==3
   #...  ...#     ...#...  ...#...
[P]#...  ...#[P]  ...#...  ...#...
   #...  ...#     ...#...  ...#...
#######  #######  #######  #######
...#...  ...#...     #...  ...#   
...#...  ...#...  [P]#...  ...#[P]
...#...  ...#...     #...  ...#   
```

예

입력을 고려하십시오 L = [2,0]. #1x1 그리드로 시작 L하여 오른쪽에서 횡단 합니다. 가장 오른쪽에있는 요소는 01 × 1 격자의 사본 4 개를 가져 와서 .첫 번째 격자 를 바꾸고 #해시로 붙입니다. 결과적으로 3 × 3 그리드

##.
###
.#.

다음 요소는 2 . 그래서 우리는 3 × 3 격자의 4 개의 사본을 가져 와서 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]
.......#...#...#...............#...............................
.......#...#...#...............#...............................
.......#...#...#...............#...............................
.......#########...............#...............................
.......#.#.#...#...............#...............................
.......#####...#...............#...............................
.......#.###...#...............#...............................
################...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
################################...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
###############################################################
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................

code-golf ascii-art fractal

— 자브
소스

귀하의 예에서 1x1 그리드로 시작하는 이유는 #무엇입니까? L !=[]이 예에서는 하나 이상의 요소가 있으므로 이 F (L) 인 것을 의미 하는가 항상# 처음?

— R. Kap

2

@ R.Kap 자, 예는 명확하지 않습니다. 정의는 재귀 L = [2,0]적이므로 헤드 F([0])를 잘라 내고 패턴 을 본 다음 헤드를 잘라 내고 [0]패턴을 봅니다 ( F([])1x1 그리드) #. 그런 다음 잘린 인덱스 0를 사용하여 3x3 패턴을 만들고 그 잘린 인덱스 2를 사용하여 7x7 패턴을 만듭니다. 귀하의 질문에 대답하려면 : 예, 재귀의 기본 사례이므로 항상 1x1 그리드로 시작합니다.

— Zgarb

CJam, 59 47 43 41 40 바이트

1 바이트를 절약 한 Sp3000에 감사합니다.

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

— 마틴 엔더
소스

3

MATL , 42 41 바이트

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

온라인으로 사용해보십시오!

설명

이것은 Kronecker 제품 을 사용하여 반복적으로 작동하여 각 반복에서 배열을 확장합니다. 이 배열은 0및 1대신에 와 대신에 만들어 .지며 #끝에 적절한 문자로 바뀝니다.

입력 크기만큼 반복됩니다. 입력은 오른쪽에서 왼쪽으로 처리됩니다. 반복 색인은에서 시작합니다 1.

챌린지 예제를 input과 함께 사용 [2,0]하면 배열이 다음과 같이 초기화됩니다.

1 2
3 4

이것은 하나의 행과 하나의 열로 확장 된 초기 1( #)에 해당하며 나중에 목적이 명확합니다. 해당 열의 값은 덮어 쓰기 때문에 중요하지 않습니다. 그들은 똑같이 될 수 있습니다.

1 1
1 1

반복 할 때마다 기존 배열에 크로네 커가 곱해지고 1입력의 현재 항목이 나타내는 위치와 0다른 항목 이 포함 된 2 × 2 0 원 배열이 곱해집니다 . 반복 i = 1 의 예에서 가장 오른쪽 입력 항목은 0이므로 0-1 배열은

1 0
0 0

이 두 배열의 크로네 커 곱은

다음으로, 인덱스 2^i가 있는 행과 열은 다음과 같이 채워집니다.

처음 세 행과 열은 첫 번째 반복의 결과를 구성합니다. 이전과 마찬가지로 추가 행과 열이 있는데, 이는 다음 반복에서 배열을 확장하는 데 유용합니다.

반복 i = 2 일 때, 현재 입력 값에 2위의 배열이 포함되어 있기 때문에 크로네 커 곱하기

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행과 열을 1로 채우면

 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

— 루이스 멘도
소스

2

하스켈, 123122 바이트

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.

— 니미
소스

1

자바 스크립트 (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

재귀 호출의 결과를 가져온 다음 각 줄 자체를 해시 + 같은 길이의 도트 문자열로 바꾸고 필요한 경우 역순으로 바꾼 다음 부분 결과에서 줄 바꿈과 중앙 열을 제외하고 도트 문자열을 만듭니다. 해시 및 주변 줄 바꿈이있는 해시 문자열을 차례로 사용하여 세 문자열을 적절한 순서로 결합합니다.

— 닐
소스

1

루비, 143134 바이트

익명의 기능.

첫 번째 줄을 다시 정렬하여 1 바이트를 절약했습니다. z가 수식에서 테이블로 증가하는 방식을 변경하여 6 바이트를 절약했습니다. 변수를 제거하여 2 바이트를 절약했습니다 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}

테스트 프로그램에서 언 골프

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

— 레벨 리버 스트리트
소스

0

루비, 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"
"}

— 가치 잉크
소스

0

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

참고 : 입력 은 목록으로 제공 되어야 합니다.

설명이없는 골퍼

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

더 광범위하고 훨씬 시각적으로 매력적인 설명 :

더 광범위하고 훨씬 시각적으로 호소력있는 설명을 위해 입력 목록이 인 위의 코드에서 "메인"루프를 두 번째로 살펴보십시오 [0,2]. 이 경우 "메인"목록의 요소 l는 다음과 같습니다.

.#.
###
##.

과

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

그리고 list y만 포함합니다 0. 파이썬에서 grid의 마지막 요소를 인덱싱하는 방법을 사용하여 그리드 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의 상단 가장자리 길이를 전체적으로 찾을 수 있습니다. (중간 #과 \n끝 을 포함하려면 +2 ). 우리는 그 방정식을 사용할 수 있습니다.이 방정식을 사용 i하면 목록을 만들고 _범위에서 0=>length of grid l[-1], 해당 항목이의 배수이고 i또한 _같지 않은i*(2^(n-1)-1) , 그래서 우리는 중간 세그먼트를 제외 할 수 있음#s 상단 절반을 하단 절반에서 분리합니다. 그러나 우리는 맨 왼쪽의 요소뿐만 아니라 왼쪽의 모든 점 요소를 원합니다. 글쎄, 그것에 대한 수정이 있으며, 단순히 i+h범위 0=>2^(n-1)의 값 0=>length of grid l[-1]이 목록에 추가 될 때 마다 h가 범위의 모든 정수를 포함하는 목록을 목록 에 추가하는 것입니다. 점의 1 사분면의 길이만큼 목록에 추가 된 많은 수의 값. 그리고 그것은 list 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)# 상단을 분리들과 우리는 실제로 8,16,32 등이 필요하지 않기 때문에 _가 이미 목록 a에 있지 않은 반쪽. 목록에b. 그리고 지금, 우리는 다시 특정 인덱스만을 원하지 않습니다. 그리드 오른쪽에 모든 점 문자가 필요합니다. 우리가 list에서 한 것처럼 a, 여기서 우리는 범위에서 각 정수가 어디에 있는지의 목록을 b목록에 추가 할 수도 있습니다 ._+hh0=>2^(n-1)

이제 우리는 목록 a과 b포장이 준비되어 있습니다. 우리는 지금 이것을 어떻게 모을 것인가? 리스트는 곳이다 W, T, G, 그리고 C와서. 그들은 격자 점의 각각의 특정 사분면에 인덱스를 개최한다 l[-1]. 예를 들어 W그리드의 사분면 1 (인덱스 0)과 동일한 모든 인덱스의 목록으로 목록을 예약 해 봅시다 . 이 목록 2^(n-1)에서 list 의 첫 번째 목록 을 추가합니다. alist a는 그리드의 왼쪽 절반에있는 점에 대한 모든 인덱스를 W포함 하고 이제 (2^(n-1))*(2^(n-1))요소를 포함 하도록 모두 분할합니다 . list와 동일 T하지만 Tlist의 요소를 포함 하는 차이점 이 있습니다.b 있기 때문에T사분면 2 (인덱스 1) 용으로 예약되어 있습니다. list G는 list W의 나머지 요소를 포함한다는 점을 제외하고 list와 동일 a하며 list C는 T이제 list 의 나머지 요소를 포함한다는 점을 제외하면 list와 동일 합니다 b. 그리고 그게 다야! 이제 그리드에 점을 포함하는 모든 사분면에 대한 인덱스 값이 있으며 각 사분면에 해당하는 네 개의 목록으로 나뉩니다. 이제이 4 개의리스트 (W, T, G, C)를 사용 l[-1]하여 그리드 l[0]에서 어떤 문자를 그리드의 각 문자로 대체해야하는지 프로그램에 알려줄 수 있습니다. 이것은 리스트의 첫 번째 요소입니다 l. 값이 0여기에 있으므로 1 사분면 (인덱스 0)의 모든 점 l[0]을 목록을 사용 하는 그리드로 바꿉니다.W.

따라서 마침내 다음과 같은 결과가 나타납니다.

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

아휴! 긴 과정이지? 그러나 그것은 완벽하게 작동하며 다시는 더 행복 할 수 없었습니다. :)

— R. 캅
소스

인덱스 프랙탈 그리기

소개

예

입력

산출