Một dòng chảy rắn, còn được gọi là một đường cong Gosper , là một đường cong fractal, phát triển theo cấp số nhân trong kích thước với mỗi đơn hàng / lần lặp của một quá trình đơn giản. Dưới đây là các chi tiết về việc xây dựng và một vài ví dụ cho các đơn đặt hàng khác nhau:

Đặt hàng 1 con rắn :

____
\__ \
__/

Đặt hàng 2 con rắn chảy :

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

Đặt hàng 3 con rắn :

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

Xây dựng

Hãy xem xét thứ tự 1 Flow Snake được xây dựng theo một đường dẫn chứa 7 cạnh và 8 đỉnh (được dán nhãn bên dưới. Mở rộng cho tính khả thi):

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

Bây giờ cho mỗi đơn hàng tiếp theo, bạn chỉ cần thay thế các cạnh bằng một phiên bản xoay của mẫu 1 đơn hàng ban đầu này. Sử dụng 3 quy tắc sau để thay thế các cạnh:

1 Đối với cạnh ngang, thay thế nó bằng hình dạng ban đầu như sau:

________
\       \
 \____   \
     /
____/

2 Đối với /cạnh ( 12trong cấu trúc trên), thay thế nó bằng phiên bản xoay sau:

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

3 Đối với \cạnh ( 34và 67ở trên), thay thế nó bằng phiên bản xoay sau:

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

Vì vậy, ví dụ, thứ tự 2 với các đỉnh từ thứ tự 1 được dán nhãn sẽ trông giống như

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

Bây giờ đối với bất kỳ thứ tự cao hơn nào, bạn chỉ cần chia mức hiện tại thành các cạnh có độ dài 1 /, 1 \hoặc 2 _và lặp lại quy trình. Xin lưu ý rằng ngay cả sau khi thay thế, các đỉnh chung giữa hai cạnh liên tiếp bất kỳ vẫn trùng nhau.

Thử thách

• Bạn phải viết một hàm của một chương trình đầy đủ nhận một số nguyên duy nhất Nthông qua đối số hàm STDIN / ARGV / hoặc tương đương gần nhất và in lệnh NFlow Snake trên STDOUT.
• Số nguyên đầu vào luôn lớn hơn 0.
• Không nên có bất kỳ không gian hàng đầu nào không phải là một phần của mẫu.
• Không nên có không gian dấu hoặc đủ khoảng trống để đệm mẫu để điền hoàn toàn hình chữ nhật giới hạn tối thiểu.
• Trailing newline là tùy chọn.

Những điều lý thú

• Flow Snakes là một trò chơi chữ của Snow Flakes, mô hình này giống với thứ tự 2 trở lên
• Flow và Rắn thực sự đóng một phần trong mô hình khi mô hình được tạo thành từ một con đường duy nhất chảy xuyên suốt.
• Nếu bạn chú ý cẩn thận, mẫu thứ tự 2 (và cao hơn nữa) bao gồm các phép quay của mẫu thứ tự 1 được xoay trên đỉnh chung của cạnh hiện tại và cạnh trước.
• Có một biến thể Non ASCII của Flow Snakes có thể được tìm thấy ở đây và tại một số địa điểm khác.

Đây là mã golf để mã ngắn nhất trong byte giành chiến thắng!

Bảng xếp hạng

Bài đầu tiên của loạt bài tạo ra một bảng thành tích.

Để đảm bảo rằng câu trả lời của bạn hiển thị, vui lòng bắt đầu mọi câu trả lời bằng tiêu đề, sử dụng mẫu Markdown sau:

# Language Name, N bytes

nơi Nlà kích thước của trình của bạn. Nếu bạn cải thiện điểm số của mình, bạn có thể giữ điểm số cũ trong tiêu đề, bằng cách đánh bại chúng thông qua. Ví dụ:

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

CJam, 144 byte

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*

Dòng mới được thêm vào để tránh cuộn. Dùng thử trực tuyến

Chương trình hoạt động theo nhiều bước:

1. Fractal ban đầu (thứ tự 1) được mã hóa thành một chuỗi gồm 7 góc (về mặt khái niệm, bội số của 60 °) đại diện cho hướng di chuyển
2. Fractal được "áp dụng" cho một phân đoạn ngang (thứ tự 0 fractal) N lần để tạo ra tất cả các "chuyển động" theo thứ tự N fractal
3. Bắt đầu từ [0 0], các chuyển động được dịch thành một chuỗi các điểm có tọa độ [xy]
4. Mỗi phân đoạn (cặp điểm) được chuyển đổi thành bộ ba 1 hoặc 2 [xyc], đại diện cho ký tự c tại tọa độ x, y
5. Hình chữ nhật giới hạn được xác định, tọa độ được điều chỉnh và tạo ra một ma trận khoảng trắng
6. Đối với mỗi bộ ba, ký tự c được đặt ở vị trí x, y trong ma trận và ma trận cuối cùng được điều chỉnh cho đầu ra

Python 2, 428 411 388 byte

Điều này là khá khó khăn. Các mẫu không giữ tỷ lệ của chúng sau mỗi bước có nghĩa là rất khó để tạo ra một hình ảnh từ người tiền nhiệm. Những gì mã này làm, mặc dù nó không thể đọc được sau khi chơi golf cường độ cao, thực sự là vẽ đường thẳng từ đầu đến cuối bằng cách sử dụng Dhàm được định nghĩa đệ quy .

Kích thước cũng là một vấn đề và cuối cùng tôi chỉ bắt đầu ở giữa một 5*3**nhình vuông cạnh và cắt xén mọi thứ sau đó, mặc dù nếu tôi có thể nghĩ ra cách tốt hơn để tính kích thước tôi có thể thay đổi 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

JavaScript ( ES6 ), 356 362 370

Đó là một điều khó khăn ...

Mỗi hình dạng được lưu trữ như một đường dẫn. Có 6 khối xây dựng cơ bản (lùi 3 + 3)

• 0đường chéo lên trái sang dưới phải ( 4lùi)
• 1đường chéo từ dưới trái sang lên phải ( 5lùi)
• 2ngang trái sang phải ( 6lùi)

Đối với mỗi một, có một bước thay thế sẽ được áp dụng khi tăng thứ tự:

• 0-> 0645001(lùi 4-> 5441024)
• 1-> 2116501(lùi 5-> 5412556)
• 2-> 2160224(lùi 6-> 0664256)

các giá trị được điền sẵn trong hmảng, ngay cả khi các phần tử 4..6 có thể được lấy từ 0..2 bằng cách sử dụng

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

Để có được hình dạng cho thứ tự đã cho, đường dẫn được xây dựng trong biến p áp dụng các thay thế lặp đi lặp lại. Sau đó, vòng lặp chính lặp lại trên biến p và vẽ hình bên trong mảng g [], trong đó mỗi phần tử là một hàng.
Bắt đầu từ vị trí (0,0), mỗi chỉ số có thể trở thành âm (chỉ số y ở mức cao). Tôi tránh các chỉ số y âm thay đổi tất cả các mảng g bất cứ khi nào tôi tìm thấy một giá trị y âm. Tôi không quan tâm nếu chỉ số x trở nên âm, vì trong các chỉ mục phủ định của JS được cho phép, chỉ khó quản lý hơn một chút.
Ở bước cuối cùng, tôi quét mảng chính bằng cách sử dụng .map, nhưng với mỗi hàng tôi cần sử dụng một vòng lặp rõ ràng cho (;;) bằng cách sử dụng bbiến chứa chỉ số x nhỏ nhất đạt được (sẽ là <0).
bên trongconsole.log phiên bản có một dòng mới hàng đầu tiện dụng, có thể dễ dàng tạo một dòng mới theo dõi hoán đổi 2 hàng, như trong phiên bản đoạn trích.

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

Đoạn mã tiện dụng để kiểm tra (trong 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>

Haskell, 265 byte

(?)=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]]

(Lưu ý: trên GHC trước 7.10, bạn sẽ cần thêm import Control.Applicativehoặc thay thế abs<$>bằng map abs$.)

Chạy trực tuyến tại Ideone.com

f n :: Int -> IO ()vẽ mức độ nchảy. Bản vẽ được tính theo thứ tự bitmap chứ không phải dọc theo đường cong, cho phép thuật toán chạy trong không gian O (n) (nghĩa là logarit trong kích thước bản vẽ). Gần một nửa số byte của tôi được sử dụng để tính toán hình chữ nhật nào!

Perl, 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

Tham số được thực hiện trên đầu vào tiêu chuẩn. Kiểm tra tôi .

Haskell, 469 419 390 385 365 byte

hàm f :: Int-> IO () lấy một số nguyên làm đầu vào và in con rắn dòng

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 byte

Tôi đoán là không có kẻ đánh bại Perl và Haskell, nhưng vì chưa có bài nộp C nào ở đây:

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

Để tiết kiệm dung lượng trong cuộc gọi atoi (), số lượng đối số được truyền cho chương trình được sử dụng cho cấp độ.

Chương trình chạy trong O (n ^ 3) hoặc tệ hơn; đầu tiên, đường dẫn được tính một lần để tìm tọa độ min / max, sau đó với mỗi cặp (x, y), nó được tính một lần để tìm ký tự trên vị trí cụ thể đó. Rất chậm, nhưng tiết kiệm quản trị bộ nhớ.

Ví dụ chạy tại http://codepad.org/ZGc648Xi

Python 2, 523 502 475 473 467 450 437 byte

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, tốn của tôi khoảng 3 giờ, nhưng rất vui để làm!

Ý tưởng là phân chia nhiệm vụ theo nhiều bước:

1. Tính tất cả các cạnh (được mã hóa thành 0-5) theo thứ tự xuất hiện (từ đầu đến cuối con rắn)
2. Tính toán vị trí cho mỗi cạnh (và lưu giá trị min và max cho x và y)
3. Xây dựng chuỗi bao gồm (và sử dụng các giá trị tối thiểu để bù, để chúng tôi không nhận được các chỉ số phủ định)
4. In chuỗi

Đây là mã ở dạng không được phép:

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

Chỉnh sửa: Tôi đã thay đổi ngôn ngữ thành python 2, để tương thích với câu trả lời của tôi cho # 3 (và nó cũng tiết kiệm thêm 6 byte)

Pari / GP, 395

Vòng lặp trên các vị trí ký tự x, y và tính toán char nào sẽ in. Nỗ lực vừa phải ở mức tối thiểu hóa, ghi điểm với khoảng trắng và bình luận bị tước.

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

Mỗi char là đầu tiên hoặc thứ hai của một hình lục giác. Vị trí ô là một số phức z được chia thành cơ sở b = 2 + w với các chữ số 0, 1, w ^ 2, ..., w ^ 5, trong đó w = e ^ (2pi / 6) gốc thứ sáu của sự thống nhất. Các chữ số này được giữ giống như một phân biệt từ 1 đến 7, sau đó được đưa từ cao xuống thấp thông qua bảng trạng thái để xoay ròng. Đây là phong cách mã dòng chảy của Ed Shouten (xytoi) nhưng chỉ để xoay thuần, không biến các chữ số thành chỉ số "N" dọc theo đường dẫn. Các phạm vi có liên quan đến gốc 0 ở trung tâm của hình. Miễn là giới hạn không phải là điểm cuối, đây là giữa của một hình lục giác 2 ký tự và chỉ cần 1 ký tự đó. Nhưng khi con rắn bắt đầu và / hoặc kết thúc là giới hạn X thì cần 2 ký tự, đó là k = 0 bắt đầu và k <3 kết thúc. Pari có "quads" như sqrt (-3) dựng sẵn nhưng điều tương tự có thể được thực hiện với các phần thực và phần ảo riêng biệt.