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

Порядок 1 Flow Snake :

____
\__ \
__/

Порядок 2 Flow Snake :

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

Порядок 3 Flow Snake :

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

строительство

Рассмотрим построение потока 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 / или ближайший эквивалент и печатает порядок NFlow Snake на STDOUT.
• Входное целое число всегда больше чем 0.
• Не должно быть никаких начальных пробелов, которые не являются частью шаблона.
• Не должно быть либо конечных пробелов, либо достаточно пробелов, чтобы заполнить шаблон, чтобы полностью заполнить минимальный ограничивающий прямоугольник.
• Трейлинг новой строки не является обязательным.

Забавные факты

• Flow Snakes - игра слов снежных хлопьев, которая напоминает эту модель для порядка 2 и выше.
• Поток и Змеи на самом деле играют роль в паттерне, так как паттерн состоит из единственного пути, проходящего по всему.
• Если вы внимательно обратите внимание, паттерн порядка 2 (и выше) также состоит из поворотов паттерна порядка 1, повернутых на общей вершине текущего и предыдущего ребра.
• Существует не ASCII-вариант Flow Snakes, который можно найти здесь и в нескольких других местах.

Это код-гольф, поэтому выиграй самый короткий код в байтах!

Leaderboard

Первый пост серии генерирует таблицу лидеров.

Чтобы убедиться, что ваши ответы отображаются, начните каждый ответ с заголовка, используя следующий шаблон уценки:

# 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 при высоких ордерах). Я избегаю отрицательных индексов y, сдвигающих весь данный массив всякий раз, когда я нахожу отрицательное значение y. Мне все равно, станет ли индекс x отрицательным, так как в JS допустимы отрицательные индексы, чуть более сложными в управлении.
На последнем шаге я сканирую основной массив, используя .map, но для каждой строки мне нужно использовать явный цикл for (;;), используя 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 ()рисует уровень nflownake. Чертеж вычисляется в порядке растрового изображения, а не вдоль кривой, что позволяет алгоритму работать в пространстве O (n) (то есть логарифмически по размеру рисунка). Почти половина моих байтов потрачена на вычисление, какой прямоугольник нарисовать!

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

Параметр взят на стандартный ввод. Проверь меня .

Haskell, 469 419 390 385 365 байт

функция f :: Int-> IO () принимает целое число в качестве входных данных и печатает поток Snake

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) или хуже; сначала путь вычисляется один раз, чтобы найти координаты min / max, затем для каждой пары (x, y) он рассчитывается один раз, чтобы найти символ в этом конкретном месте. Ужасно медленно, но экономит на администрировании памяти.

Пример запуска на http://codepad.org/ZGc648Xi

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

Пфффт, мне это стоило 3 часа, но было весело!

Идея состоит в том, чтобы разбить задачу на несколько этапов:

1. Рассчитать все ребра (закодированные как 0-5) в порядке появления (так от начала змеи до конца)
2. Рассчитать положение для каждого из ребер (и сохранить минимальное и максимальное значения для х и у)
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, а затем переводятся от максимума к минимуму через таблицу состояний для вращения сети. Это в стиле кода потокового змея Эд Shouten (xytoi), но только для чистого вращения, не превращая цифры в индекс «N» вдоль пути. Экстенты относятся к началу 0 в центре фигуры. Пока предел не является конечной точкой, это середина 2-символьного шестиугольника, и необходим только 1 из этих символов. Но когда начало и / или конец змеи являются X пределом, необходимо 2 символа, то есть k = 0 начало и k <3 конец. В Pari есть «квадраты», такие как sqrt (-3), но то же самое можно сделать с реальными и мнимыми частями по отдельности.