Потік Змія, також відомий як кривої Госпер , є фрактальної кривої, зростає в геометричній прогресії за розміром з кожним порядку / ітерації процесу простий. Нижче наведено деталі про будівництво та кілька прикладів для різних замовлень:

Замовляйте 1 змії :

____
\__ \
__/

Замовити 2 змії :

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

Замовити 3 змії :

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

Будівництво

Розглянемо порядок 1 Потік змії будується зі шляху, що містить 7 країв і 8 вершин (позначено нижче. Збільшений для доцільності):

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

Тепер для кожного наступного замовлення ви просто замінюєте краї на поворотну версію цього оригінального шаблону 1 замовлення. Використовуйте наступні 3 правила для заміни ребер:

1 Для горизонтального краю замініть його оригінальною формою так:

________
\       \
 \____   \
     /
____/

2 Для /краю ( 12у наведеній конструкції) замініть його на наступний поворотний варіант:

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

3 Для \краю ( 34і 67вище) замініть його на наступний поворотний варіант:

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

Так, наприклад, виглядатиме замовлення 2 з вершинами від позначення порядку 1

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

Тепер для будь-якого вищого порядку просто розділіть поточний рівень на краї довжиною 1 /, 1 \або 2 _і повторіть процес. Зауважте, що навіть після заміни загальні вершини між будь-якими двома послідовними ребрами все ще збігаються.

Виклик

• Вам потрібно записати функцію повної програми, яка отримує єдине ціле число Nчерез аргумент STDIN / ARGV / function або найближчий еквівалент і друкує порядок Nпотоку Snake на STDOUT.
• Ціле вхід завжди більше, ніж 0.
• Не повинно бути провідних пробілів, які не входять до структури.
• Не повинно бути або пробілів, або достатньо пробілів, щоб залити шаблон, щоб повністю заповнити мінімальний обмежуючий прямокутник.
• Новий рядок не є обов'язковим.

Цікаві факти

• Flow Snakes - це гра в слова «Снігові пластівці», що ця картина нагадує для порядку 2 і вище
• Потік і Змії насправді відіграють певну роль у візерунку, оскільки візерунок складається з єдиного шляху, що протікає по всьому.
• Якщо ви помітили уважно, рисунок порядку 2 (і вище) складається з обертів візерунка 1 порядку, скручених на загальній вершині поточного та попереднього краю.
• Є варіант ASCII Flow Snakes, який можна знайти тут і в кількох інших місцях.

Це код-гольф, тому найкоротший код у виграші байтів!

Таблиця лідерів

Перший пост серії генерує таблицю лідерів.

Щоб відповіді відображалися, почніть кожну відповідь із заголовка, використовуючи такий шаблон Markdown:

# 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. Фрактал "застосовується" до горизонтального відрізка (порядок 0 фрактального) N разів для генерування всіх "рухів" у порядку N фрактала
3. Починаючи з [0 0], рухи переводяться в послідовність точок з координатами [xy]
4. Кожен відрізок (пара точок) перетворюється на 1 або 2 [xyc] трійки, що представляють символ c за координатами x, y
5. Визначається обмежуючий прямокутник, коригуються координати і формується матриця пробілів
6. Для кожного триплета символ c розміщується у положенні x, y в матриці, а кінцева матриця коригується для виведення

Python 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

JavaScript ( 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 при високих порядках). Я уникаю від'ємних індексів, що зміщують весь масив g, коли я знаходжу негативне значення y. Мені все одно, чи індекс x стане негативним, як в JS дозволені негативні індекси, просто трохи складніше керувати.
На останньому кроці я сканую основний масив за допомогою .map, але для кожного рядка мені потрібно використовувати явний цикл (;;), використовуючи bзмінну, яка містить найменший досягнутий індекс x (це буде <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>

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

(Примітка: на GHC , перш ніж 7.10, то вам потрібно додати 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

Параметр, прийнятий на стандартному вході. Випробуй мене .

Haskell, 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 байт

Гадаю, хлопці Перла та Хаскелла, я думаю, але оскільки тут ще немає подання на С:

#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) або гірше; спочатку шлях обчислюється один раз, щоб знайти координати min / max, потім для кожної пари (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. Обчисліть позицію для кожного з ребер (і збережіть значення min і max для x і y)
3. Побудуйте рядки, з яких він складається (і використовуйте мінімальні значення для компенсації, щоб ми не отримали негативні показники)
4. Роздрукуйте рядки

Ось код у неозореному вигляді:

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

Редагувати: я змінив мову на python 2, щоб бути сумісною з моєю відповіддю №3 (а також економить ще 6 байт)

Пари / ГП, 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())
}

Кожен знак є першим або другим з шестикутника. Розташування комірки - це складне число z, розділене на основу b = 2 + w з цифрами 0, 1, w ^ 2, ..., w ^ 5, де w = e ^ (2pi / 6) шостий корінь одиниці. Ці цифри зберігаються так само, як відмінні від 1 до 7, а потім приймаються від високих до низьких через таблицю стану для чистого обертання. Це в стилі потокового коду Еда Шутена (xytoi), але лише для чистого обертання, не вносячи цифр в індекс "N" по шляху. Розміри відносно початку 0 в центрі форми. Поки межа не є кінцевою точкою, вони є серединою двозначного шестикутника і потрібна лише 1 з цих символів. Але коли старт змії і / або кінець є обмеженням X, потрібні два знаки, це k = 0 початок і k <3 кінець. У Пари є вбудовані "квадроцикли", як sqrt (-3), але те ж саме можна зробити з реальними та уявними частинами окремо.