Gosper 곡선이라고도 하는 Flow Snake 는 간단한 프로세스의 각 순서 / 반복에 따라 크기가 기하 급수적으로 증가하는 프랙탈 곡선입니다. 다음은 시공에 대한 세부 사항과 다양한 주문에 대한 몇 가지 예입니다.

주문 1 Flow Snake :

____
\__ \
__/

주문 2 Flow Snake :

      ____
 ____ \__ \
 \__ \__/ / __
 __/ ____ \ \ \
/ __ \__ \ \/
\ \ \__/ / __
 \/ ____ \/ /
    \__ \__/
    __/

주문 3 Flow Snake :

                 ____
            ____ \__ \
            \__ \__/ / __
            __/ ____ \ \ \    ____
           / __ \__ \ \/ / __ \__ \
      ____ \ \ \__/ / __ \/ / __/ / __
 ____ \__ \ \/ ____ \/ / __/ / __ \ \ \
 \__ \__/ / __ \__ \__/ / __ \ \ \ \/
 __/ ____ \ \ \__/ ____ \ \ \ \/ / __
/ __ \__ \ \/ ____ \__ \ \/ / __ \/ /
\ \ \__/ / __ \__ \__/ / __ \ \ \__/
 \/ ____ \/ / __/ ____ \ \ \ \/ ____
    \__ \__/ / __ \__ \ \/ / __ \__ \
    __/ ____ \ \ \__/ / __ \/ / __/ / __
   / __ \__ \ \/ ____ \/ / __/ / __ \/ /
   \/ / __/ / __ \__ \__/ / __ \/ / __/
   __/ / __ \ \ \__/ ____ \ \ \__/ / __
  / __ \ \ \ \/ ____ \__ \ \/ ____ \/ /
  \ \ \ \/ / __ \__ \__/ / __ \__ \__/
   \/ / __ \/ / __/ ____ \ \ \__/
      \ \ \__/ / __ \__ \ \/
       \/      \ \ \__/ / __
                \/ ____ \/ /
                   \__ \__/
                   __/

구성

1 개의 흐름 뱀이 7 개의 모서리와 8 개의 정점 (아래에 표시되어 있습니다. 타당성을 위해 확대됨)을 포함하는 경로로 구축되도록 주문합니다

4____5____6
 \         \
 3\____2   7\
       /
0____1/

이제 다음 순서마다 모서리를이 원래 순서 1 패턴의 회전 된 버전으로 바꾸십시오. 모서리를 교체하려면 다음 3 가지 규칙을 사용하십시오.

1 수평 가장자리의 경우 그대로 원래 모양으로 교체하십시오.

________
\       \
 \____   \
     /
____/

이 경우 a /(에지 12상기 구성에서), 다음 회전 된 버전으로 대체 :

 /
/   ____
\  /   /
 \/   /
     /
____/

3 의 경우 a \에지 ( 34및 67위), 다음 회전 된 버전으로 대체 :

 /
/   ____ 
\   \   \
 \   \   \
  \  /
   \/

예를 들어, 주문 1의 정점이있는 주문 2는 다음과 같습니다.

            ________
            \       \
  ________   \____   \6
  \       \      /   /
   \____   \5___/   /   ____
       /            \   \   \
  4___/   ________   \   \   \7
 /        \       \   \  /
/   ____   \____   \2  \/
\   \   \      /   /
 \   \   \3___/   /   ____
  \  /            \  /   /
   \/   ________   \/   /
        \       \      /
         \____   \1___/
             /
        0___/

이제 더 높은 차수의 경우 현재 레벨을 길이 1 /, 1 \또는 2의 가장자리로 나누고 _프로세스를 반복하십시오. 교체 후에도 두 개의 연속 모서리 사이의 공통 정점이 여전히 일치한다는 점에 유의하십시오.

도전

• NSTDIN / ARGV / 함수 인수 또는 가장 가까운 해당 인수를 통해 단일 정수 를 수신하고 NSTDOUT에 순서 스네이크를 인쇄 하는 전체 프로그램의 함수를 작성해야합니다 .
• 입력 정수는 항상보다 큽니다 0.
• 패턴의 일부가 아닌 선행 공백이 없어야합니다.
• 최소 경계 사각형을 완전히 채우기 위해 패턴을 채울 수있는 후미 공백이나 후미 공백이 없어야합니다.
• 후행 줄 바꿈은 선택 사항입니다.

재미있는 사실

• Flow Snakes는 Snow Flakes의 단어 놀이로,이 패턴은 2 번 이상과 유사합니다.
• 플로우와 스네이크는 패턴이 전체적으로 흐르는 단일 경로로 구성되므로 실제로 패턴의 일부를 담당합니다.
• 주의해서 알면 차수 2 (및 그 이상) 패턴은 현재와 이전 가장자리의 공통 정점에서 피벗 된 차수 1 패턴의 회전으로 구성됩니다.
• Flow Snakes의 ASCII가 아닌 변형이 있으며 여기 와 다른 여러 위치에서 찾을 수 있습니다 .

이것은 코드 골프 이므로 바이트 단위의 가장 짧은 코드가 승리합니다!

리더 보드

시리즈의 첫 번째 게시물은 리더 보드를 생성합니다.

답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 모든 답변을 헤드 라인으로 시작하십시오.

# Language Name, N bytes

N제출물의 크기는 어디에 있습니까 ? 당신이 당신의 점수를 향상시킬 경우에, 당신은 할 수 있습니다 를 통해 눈에 띄는에 의해, 헤드 라인에 오래된 점수를 유지한다. 예를 들어 :

# Ruby, <s>104</s> <s>101</s> 96 bytes

CJam, 144 바이트

0_]0a{{_[0X3Y0_5]f+W@#%~}%}ri*{_[YXW0WW]3/If=WI6%2>#f*.+}fI]2ew{$_0=\1f=~-
"__1a /L \2,"S/=(@\+\~.+}%_2f<_:.e>\:.e<:M.-:)~S*a*\{M.-~3$3$=\tt}/zN*

스크롤을 피하기 위해 줄 바꿈이 추가되었습니다. 온라인으로 사용해보십시오

이 프로그램은 여러 단계로 작동합니다.

1. 초기 프랙탈 (차수 1)은 이동 방향을 나타내는 7 개 각도 (개념적으로 60 °의 배수)로 인코딩됩니다.
2. 프랙탈은 N 세그먼트의 순서대로 모든 "움직임"을 생성하기 위해 수평 세그먼트 (0 프랙탈)에 N 번 적용된다.
3. [0 0]부터 이동은 [xy] 좌표를 사용하여 일련의 포인트로 변환됩니다.
4. 각 세그먼트 (점 쌍)는 좌표 x, y에서 문자 c를 나타내는 1 또는 2 개의 [xyc] 삼중으로 변환됩니다.
5. 경계 사각형이 결정되고 좌표가 조정되며 공간 행렬이 생성됩니다.
6. 각 삼중 항에 대해 문자 c는 행렬에서 위치 x, y에 배치되고 최종 행렬은 출력에 맞게 조정됩니다.

파이썬 2, 428 411 388 바이트

이것은 꽤 까다 롭습니다. 패턴은 각 단계 후에 비율을 유지하지 않으므로 이전 모델에서 절차 적으로 이미지를 생성하기가 매우 어렵습니다. 이 코드는 강렬한 수학 골프 후에 읽을 수 없지만 재귀 적으로 정의 된 D함수를 사용하여 처음부터 끝까지 선을 그립니다 .

크기도 문제였으며, 나는 5*3**n정사각형 사각형 의 중간에서 시작하여 나중에 물건을 자르기 시작 했지만 크기를 계산하는 더 좋은 방법을 생각할 수 있다면 크기를 바꿀 수 있습니다.

n=input();s=5*3**n
r=[s*[" "]for i in[0]*s]
def D(n,x,y,t=0):
 if n<1:
    x-=t%2<1;y+=t%3>1;r[y][x]='_/\\'[t/2]
    if t<2:r[y][x+2*t-1]='_'
    return[-1,2,0,1,0,1][t]+x,y-(2<t<5)
 for c in[int(i)^t%2for i in"424050035512124224003"[t/2::3]][::(t^1)-t]:x,y=D(n-1,x,y,c)
 return x,y
D(n,s/2,s/2)
S=[''.join(c).rstrip()for c in r]
for l in[c[min(c.find('\\')%s for c in S):]for c in S if c]:print l

자바 스크립트 ( ES6 ) 356 362 370

어려운 일입니다 ...

각 모양은 경로로 저장됩니다. 6 개의 기본 빌딩 블록이 있습니다 (3 + 3 뒤로)

• 0 대각선 위 왼쪽에서 오른쪽 아래 (4 뒤로)
• 1 대각선 하단 왼쪽에서 오른쪽 (5 뒤로)
• 2가로 왼쪽에서 오른쪽 ( 6뒤로)

각각에 대해 주문을 증가시킬 때 적용되는 교체 단계가 있습니다.

• 0-> 0645001(뒤로 4-> 5441024)
• 1-> 2116501(뒤로 5-> 5412556)
• 2-> 2160224(뒤로 6-> 0664256)

h요소 4..6을 사용하여 0..2에서 얻을 수있는 경우에도 배열에 미리 채워진 값

;[...h[n]].reverse().map(x=>x^4).join('')

주어진 순서에 대한 모양을 얻기 위해 p 변수에 경로가 내장되어 대체를 반복적으로 적용합니다. 그런 다음 메인 루프는 p 변수를 반복하고 g [] 배열 내부에 모양을 그립니다. 여기서 각 요소는 행입니다.
위치 (0,0)에서 시작하여 각 지수는 음수가 될 수 있습니다 (고차의 y 지수). 음수 y 값을 찾을 때마다 음수 y 인덱스가 모든 g 배열을 이동시키는 것을 피합니다. JS 음수 색인이 허용되는 것처럼 x 색인이 음수가 될지는 신경 쓰지 않고 조금 더 관리하기가 어렵습니다.
마지막 단계에서 .map을 사용하여 기본 배열을 스캔하지만 각 행마다 b최소 x 인덱스에 도달 한 변수 를 사용하여 명시 적 for (;;) 루프를 사용해야합니다 ( <0 임).
에서console.log 버전 스 니펫 버전과 같이 편리한 행간 줄 바꿈이 있으며,이 줄 바꿈은 2 줄을 바꾸는 후행 줄 바꿈을 쉽게 만들 수 있습니다.

f=o=>{
  g=[],x=y=b=0,
  h='064500192116501921602249954410249541255690664256'.split(9);
  for(p=h[2];--o;)p=p.replace(/./g,c=>h[c]);
  for(t of p)
    z='\\/_'[s=t&3],
    d=s-(s<1),
    t>3&&(x-=d,y+=s<2),
    y<0&&(y++,g=[,...g]),r=g[y]=g[y]||[],
    s?s>1?r[x]=r[x+1]=z:r[x]=z:r[x-1]=z,
    t<3&&(x+=d,y-=s<2),
    x<b?b=x:0;
  g.map(r=>
  {
    o+='\n';
    for(x=b;x<r.length;)o+=r[x++]||' '
  },o='');
  console.log(o)
}

테스트하기 편리한 스 니펫 (Firefox) :

f=o=>{
  g=[],x=y=b=0,
  h='064500192116501921602249954410249541255690664256'.split(9);
  for(p=h[2];--o;)p=p.replace(/./g,c=>h[c]);
  for(t of p)
    z='\\/_'[s=t&3],
    d=s-(s<1),
    t>3&&(x-=d,y+=s<2),
    y<0&&(y++,g=[,...g]),r=g[y]=g[y]||[],
    s?s>1?r[x]=r[x+1]=z:r[x]=z:r[x-1]=z,
    t<3&&(x+=d,y-=s<2),
    x<b?b=x:0;
  g.map(r=>
  {
    for(x=b;x<r.length;)o+=r[x++]||' ';
    o+='\n'
  },o='');
  return o
}

// TEST

fs=9;
O.style.fontSize=fs+'px'

function zoom(d) { 
  d += fs;
  if (d > 1 && d < 40)
    fs=d, O.style.fontSize=d+'px'
}

#O {
  font-size: 9px;
  line-height: 1em;
}

<input id=I value=3><button onclick='O.innerHTML=f(I.value)'>-></button>
<button onclick="zoom(2)">Zoom +</button><button onclick="zoom(-2)">Zoom -</button>
<br>
<pre id=O></pre>

하스켈, 265 바이트

(?)=div
(%)=mod
t[a,b]=[3*a+b,2*b-a]
_#[0,0]=0
0#_=3
n#p=[352,6497,2466,-1]!!((n-1)#t[(s+3)?7|s<-p])?(4^p!!0%7)%4
0&_=0
n&p=(n-1)&t p+maximum(abs<$>sum p:p)
n!b=n&[1,-b]
f n=putStr$unlines[["__ \\/   "!!(2*n#t[a?2,-b]+a%2)|a<-[b-n!2+1..b+n!2+0^n?3]]|b<-[-n!0..n!0]]

(참고 : 7.10 이전의 GHC에서는을 추가 import Control.Applicative하거나 바꿔야 abs<$>합니다 map abs$.)

Ideone.com에서 온라인으로 실행

f n :: Int -> IO ()레벨 n흐름을 그립니다 . 도면은 곡선을 따르지 않고 비트 맵 순서로 계산되므로 알고리즘을 O (n) 공간에서 실행할 수 있습니다 (즉, 도면 크기의 로그). 내 바이트의 거의 절반이 어떤 사각형을 그릴 지 계산하는 데 소비됩니다!

펄, 334 (316) (309)

$_=2;eval's/./(map{($_,"\1"x7^reverse)}2003140,2034225,4351440)[$&]/ge;'x($s=<>);
s/2|3/$&$&/g;$x=$y=3**$s-1;s!.!'$r{'.qw($y--,$x++ ++$y,--$x $y,$x++ $y,--$x
$y--,--$x ++$y,$x++)[$&]."}=$&+1"!eeg;y!1-6!//__\\!,s/^$x//,s/ *$/
/,print for
grep{/^ */;$x&=$&;$'}map{/^/;$x=join'',map$r{$',$_}||$",@f}@f=0..3**$s*2

표준 입력에서 사용되는 매개 변수입니다. 나를 테스트 하십시오 .

하스켈 469 419 390 385 365 바이트

f :: Int-> IO () 함수는 입력으로 정수를 취하고 흐름 뱀을 인쇄합니다.

e 0=[0,0];e 5=[5,5];e x=[x]
f n=putStr.t$e=<<g n[0]
k=map$(53-).fromEnum
g 0=id
g n=g(n-1).(=<<)(k.(words"5402553 5440124 1334253 2031224 1345110 2003510"!!))
x=s$k"444666555666"
y=s$k"564645554545"
r l=[minimum l..maximum l]
s _[]=[];s w(x:y)=w!!(x+6):map(+w!!x)(s w y)
t w=unlines[["_/\\\\/_ "!!(last$6:[z|(c,d,z)<-zip3(x w)(y w)w,c==i&&d==j])|i<-r.x$w]|j<-r.y$w]

C, 479 474 468 427 바이트

내가 추측하는 Perl과 Haskell 녀석은 없지만, 여기에 C 제출이 없기 때문에 :

#define C char
C *q="053400121154012150223433102343124450553245";X,Y,K,L,M,N,i,c,x,y,o;F(C*p,
int l,C d){if(d){l*=7;C s[l];for(i=0;i<l;i++)s[i]=q[(p[i/7]%8)*7+i%7];return F
(s,l,d-1);}x=0;y=0;o=32;while(l--){c=*p++%8;for(i=!(c%3)+1;i--;) {K=x<K?x:K;L=
y<L?y:L;M=x>M?x:M;N=y>N?y:N;y+=c&&c<3;x-=c%5>1;if(x==X&y==Y)o="_\\/"[c%3];y-=c
>3;x+=c%5<2;}}return X<M?o:10;}main(l){F(q,7,l);for(Y=L;Y<N;Y++)for(X=K;X<=M;X
++)putchar(F(q,7,l));}

atoi () 호출에서 공간을 절약 하기 위해 프로그램에 전달 된 인수 수가 레벨에 사용됩니다.

프로그램이 O (n ^ 3) 이상에서 실행됩니다. 먼저 경로를 한 번 계산하여 최소 / 최대 좌표를 찾은 다음 각 (x, y) 쌍에 대해 특정 위치에서 문자를 찾기 위해 한 번 계산됩니다. 매우 느리지 만 메모리 관리를 절약합니다.

http://codepad.org/ZGc648Xi 에서 실행 예제

파이썬 2, 523 502 475 473 467 450 437 바이트

l=[0]
for _ in l*input():l=sum([map(int,'004545112323312312531204045045050445212331'[t::6])for t in l],[])
p=[]
x=y=q=w=Q=W=0
for t in l:T=t|4==5;c=t in{2,4};C=t<3;q=min(q,x);Q=max(Q,x+C);w=min(w,y);W=max(W,y);a=C*2-1;a*=2-(t%3!=0);b=(1-T&c,-1)[T&1-c];x+=(a,0)[C];y+=(0,b)[c];p+=[(x,y)];x+=(0,a)[C];y+=(b,0)[c]
s=[[' ']*(Q-q)for _ in[0]*(W-w+1)]
for t,(x,y)in zip(l,p):x-=q;s[y-w][x:x+1+(t%3<1)]='_/\_'[t%3::3]
for S in s:print''.join(S)

Pffft, 3 시간 정도의 비용이 들었지만 재미있었습니다!

아이디어는 작업을 여러 단계로 나누는 것입니다.

1. 나타나는 순서대로 모든 가장자리 (0-5로 인코딩 됨)를 계산합니다 (그러므로 뱀의 시작부터 끝까지)
2. 각 모서리의 위치를 ​​계산하고 x 및 y의 최소값과 최대 값을 저장하십시오.
3. 구성된 문자열을 빌드하십시오 (그리고 음수 지수를 얻지 않도록 최소값을 사용하여 오프셋하십시오)
4. 문자열을 인쇄

다음은 ungolfed 형식의 코드입니다.

# The input
n = int(input())

# The idea:
# Use a series of types (_, /, \, %), and positions (x, y)
# Forwards:   0: __  1: /  2: \
# Backwards:  3: __  4: /  5: \

# The parts
pieces = [
    "0135002",
    "0113451",
    "4221502",
    "5332043",
    "4210443",
    "5324551"
]
# The final types list
types = [0]
for _ in range(n):
    old = types
    types = []
    for t in old:
        types.extend(map(int,pieces[t]))

# Calculate the list of positions (and store the mins and max')
pos = []
top = False
x = 0
y = 0
minX = 0
minY = 0
maxX = 0
maxY = 0
for t in types:
    # Calculate dx
    dx = 1 if t < 3 else -1
    if t%3==0:
        dx *= 2         # If it's an underscore, double the horizontal size
    # Calculate dy
    top = t in {1, 5}
    dy = 0
    if top and t in {0, 3, 1, 5}:
        dy = -1
    if not top and t in {2, 4}:
        dy = 1
    # If backwards, add dx before adding the position to the list
    if t>2:
        x += dx
    # If top to bottom, add dy before adding the position to the list
    if t in {2,4}:
        y += dy
    # Add the current position to the list
    pos += [(x, y)]
    # In the normal cases (going forward and up) modify the x and y after changing the position
    if t<3:
        x += dx
    if t not in {2, 4}:
        y += dy
    # Store the max and min vars
    minX = min(minX, x)
    maxX = max(maxX, x + (t<3)) # For forward chars, add one to the length (we never end with __'s)
    minY = min(minY, y)
    maxY = max(maxY, y)

# Create the string (a grid of charachters)
s = [[' '] * (maxX - minX) for _ in range(maxY - minY + 1)]
for k, (x, y) in enumerate(pos):
    x -= minX
    y -= minY
    t = types[k]
    char = '/'
    if t % 3 == 0:
        char = '__'
    if t % 3 == 2:
        char = '\\'
    s[y][x : x + len(char)] = char

# Print the string
for printString in s:
    print("".join(printString))

편집 : # 3에 대한 답변 과 호환되도록 언어를 python 2로 변경 했습니다 (또한 6 바이트를 더 절약합니다)

파리 / GP, 395

x, y 문자 위치를 반복하고 인쇄 할 문자를 계산합니다. 공백을 사용하여 점수를 매기고 주석을 제거하여 보통의 최소화 시도.

k=3;
{
  S = quadgen(-12);  \\ sqrt(-3)
  w = (1 + S)/2;     \\ sixth root of unity
  b = 2 + w;         \\ base

  \\ base b low digit position under 2*Re+4*Im mod 7 index
  P = [0, w^2, 1, w, w^4, w^3, w^5];
  \\ rotation state table
  T = 7*[0,0,1,0,0,1,2, 1,2,1,0,1,1,2, 2,2,2,0,0,1,2];
  C = ["_","_",  " ","\\",  "/"," "];

  \\ extents
  X = 2*sum(i=0,k-1, vecmax(real(b^i*P)));
  Y = 2*sum(i=0,k-1, vecmax(imag(b^i*P)));

  for(y = -Y, Y,
     for(x = -X+!!k, X+(k<3),  \\ adjusted when endpoint is X limit
        z = (x- (o = (x+y)%2) - y*S)/2;
        v = vector(k,i,
                   z = (z - P[ d = (2*real(z) + 4*imag(z)) % 7 + 1 ])/b;
                   d);
        print1( C[if(z,3,
                     r = 0;
                     forstep(i=#v,1, -1, r = T[r+v[i]];);
                     r%5 + o + 1)]) );  \\ r=0,7,14 mod 5 is 0,2,4
     print())
}

각 문자는 육각형 셀의 첫 번째 또는 두 번째입니다. 셀 위치는 숫자 0, 1, w ^ 2, ..., w ^ 5를 갖는 밑수 b = 2 + w로 분리 된 복소수 z입니다. 여기서 w = e ^ (2pi / 6) 6의 근근 이 자릿수는 1에서 7까지 구별 된 다음 순 회전을위한 상태 테이블을 통해 높음에서 낮음으로 유지됩니다. 이것은 Ed Shouten 의 flowsnake 코드 스타일입니다 (xytoi)이지만 순 회전에만 적용되며 경로를 따라 숫자를 "N"인덱스로 만들지 않습니다. 범위는 모양의 중심에서 원점 0을 기준으로합니다. 제한이 끝 점이 아닌 한 2 문자 육각형의 중간이며 해당 문자 중 하나만 필요합니다. 그러나 스네이크 시작 및 / 또는 종료가 X 한계 인 2 문자가 필요합니다. 이는 k = 0 start 및 k <3 end입니다. Pari는 sqrt (-3)와 같은 "쿼드 (quad)"를 가지고 있지만 실제와 허수 부분을 별도로 사용하여 동일하게 수행 할 수 있습니다.