ASCII Искусство дня № 2 - Flow Snakes

32

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

Порядок 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
оптимизатор
источник
Если я правильно понимаю, формы 1, 2, 3 увеличены в 2 раза, поэтому нижний ряд в 2 должен состоять из 4-х знаков подчеркивания, а не из трех.
edc65
@ edc65 Фигуры в примерах имеют идеальный размер. Если вы говорите о конструктивной части, да, она увеличена, и есть 3 подчеркивания, так что число ребер занимает 4-е место
Оптимизатор
Но нет номеров ребер в форме 2 (в конструктивной части, да). Нижняя часть фигуры 2 должна быть равна нижней части фигуры 1.
edc65
@ edc65 О, вот !. Исправлена!
Оптимизатор
3
Я прочитал название как «Снежинки» и даже не заметил настоящего названия, пока вы не обратили внимание на разницу.
mbomb007

Ответы:

4

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 в матрице, а окончательная матрица корректируется для вывода
aditsu
источник
Этот ответ достаточно длинный, чтобы извлечь выгоду из байт-кодировки: goo.gl/D1tMoc
Деннис
@ Денис Я не уверен, что закончил играть в гольф ... и почему ты положил это в блок?
aditsu
Я не совсем уверен ... Ваш ответ впечатляет. Я провел целый день, пытаясь понять это правильно.
Деннис
@ Деннис Спасибо; Кстати, как вы думаете, это нормально использовать непечатные / контрольные символы? Я обычно стараюсь их избегать
aditsu
Если я могу избежать их, не увеличивая количество байтов, я это сделаю. Но короче, короче. : P В таких случаях, когда я сжимаю сам код, а не строку или массив, я обычно включаю обе версии в ответ.
Деннис
16

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
KSab
источник
Вау, это круто Хотите сделать снимок в AAoD # 1?
Оптимизатор
r=[s*[" "]for i in range(s)]-> r=[[" "]*s]*s]
побреет
1
@sirpercival, к сожалению, это не сработает из-за того, как *повторяет изменяемые объекты .
grc
о, да, я забыл
sirpercival
Вы можете сохранить несколько байтов, вставив l, переключившись print'\n'.join()на печать внутри цикла for, используя return[...][t]+x,и удаляя скобки из (t%2). Кроме того, вы можете использовать, min(c.find('\\')%s for c in S)если вы измените имя списка, Sчтобы он не перезаписывал начальное значение s.
grc
12

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>

edc65
источник
6

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) (то есть логарифмически по размеру рисунка). Почти половина моих байтов потрачена на вычисление, какой прямоугольник нарисовать!

Андерс Касеорг
источник
Я вошел в систему, и это работает сейчас! Ницца!
Оптимизатор
Оказывается, это ранее не работало на Ideone.com, потому что я предполагал 64-битный Int. Исправлено сейчас (жертвуя 2 байта).
Андерс Касорг
Это нормально, так как для входа в систему нужен только мой электронный идентификатор для подтверждения ..
Оптимизатор
5

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

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

nutki
источник
5

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]
Damien
источник
Это дает увеличенные в 2 раза цифры. Я думаю, что вопрос состоит в том, чтобы задавать меньшие цифры сверху, и использовал только увеличенные в 2 раза цифры, чтобы объяснить, как строится змея потока.
Андерс Касорг
Вы правы. Я исправил это
Дэмиен
Вы могли бы использовать $в определении k, и заменить (!!)aс (a!!)которой можно избавиться от некоторых скобок. Кроме этого, вы, кажется, сами знаете много хитростей. Ницца
гордый haskeller
4

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

Zevv
источник
Используйте X,Y,K,L,M,N,i,j,c;вместо int X,Y,K,L,M,N,i,j,c;и main(l)вместоvoid main(int l)
Spikatrix
Да, спасибо, я уже сбрил их и еще немного, я выложу новую версию.
Зевв
Вывод в последней версии кажется обрезанным и немного срезанным по краям.
Оптимизатор
Я загрузил не тот блоб, с этим все должно быть в порядке.
Зевв
4

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 байтов)

Мэтти
источник
Хорошая работа; один простое усовершенствование вы могли бы сделать бы изменения l.extend(x)в l+=x. Также вы, вероятно, можете использовать codegolf.stackexchange.com/questions/54/… вместо того, что .split()вы используете (я сделал нечто подобное в своем ответе)
KSab
@KSab Спасибо, я чувствую себя по-настоящему глупо из-за использованияextend
Мэтти
0

Пари / ГП, 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), но то же самое можно сделать с реальными и мнимыми частями по отдельности.

Кевин Райд
источник
1
Это не совсем соответствует правилам, касающимся начальных и конечных пробелов.
Андерс Касеорг
Спасибо, я исправил. Ваш Haskell побил меня на час, чтобы петля х, у сделала это. Должен был опубликовать, прежде чем ждать, чтобы увидеть, придет ли дальнейшее вдохновение :-).
Кевин Райд
Теперь конец змеи обрезается для k = 0, 1, 2. (Математика раздражает - мне пришлось с этим тоже разбираться.)
Андерс Касеорг
Ах, дорогой, когда конечной точкой является максимум х. Хм.
Кевин Райд