Arte ASCII do Dia # 2 - Flow Snakes

32

Uma serpente de fluxo, também conhecida como curva de Gosper , é uma curva fractal, que cresce exponencialmente em tamanho a cada ordem / iteração de um processo simples. Abaixo estão os detalhes sobre a construção e alguns exemplos para vários pedidos:

Encomenda 1 Flow Snake :

____
\__ \
__/

Encomenda 2 Flow Snake :

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

Encomenda 3 Flow Snake :

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

Construção

Considere a ordem 1 Flow Snake a ser construída com um caminho contendo 7 arestas e 8 vértices (rotulados abaixo. Ampliado para viabilidade):

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

Agora, para cada próximo pedido, basta substituir as bordas por uma versão girada desse padrão original de pedido 1. Use as três regras a seguir para substituir as arestas:

1 Para uma aresta horizontal, substitua-a pela forma original como está:

________
\       \
 \____   \
     /
____/

2 Para uma /aresta ( 12na construção acima), substitua-a pela seguinte versão girada:

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

3 Para uma \aresta ( 34e 67acima), substitua-a pela seguinte versão girada:

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

Por exemplo, o pedido 2 com vértices do pedido 1 rotulado terá a aparência de

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

Agora, para qualquer ordem superior, basta dividir o nível atual em arestas de comprimentos 1 /, 1 \ou 2 _e repetir o processo. Observe que, mesmo após a substituição, os vértices comuns entre duas arestas consecutivas ainda coincidem.

Desafio

  • É necessário escrever uma função de um programa completo que receba um único número inteiro Nvia argumento STDIN / ARGV / function ou o equivalente mais próximo e imprima a ordem NFlow Snake em STDOUT.
  • O número inteiro de entrada é sempre maior que 0.
  • Não deve haver espaços à esquerda que não façam parte do padrão.
  • Não deve haver espaços finais ou espaços finais suficientes para preencher o padrão e preencher completamente o retângulo mínimo.
  • A nova linha à direita é opcional.

Curiosidades

  • Flow Snakes é um jogo de palavras de Snow Flakes, que esse padrão se assemelha à ordem 2 e acima
  • O Flow e Snakes realmente desempenham um papel no padrão, pois o padrão é constituído por um único caminho que flui por todo lado.
  • Se você observar com cuidado, o padrão da ordem 2 (e também mais alto) compreende rotações do padrão da ordem 1 giradas no vértice comum da aresta atual e da aresta anterior.
  • Existe uma variante não ASCII de Flow Snakes que pode ser encontrada aqui e em vários outros locais.

Este é o pelo que o código mais curto em bytes ganha!


Entre os melhores

O primeiro post da série gera uma tabela de classificação.

Para garantir que suas respostas sejam exibidas, inicie todas as respostas com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

# Ruby, <s>104</s> <s>101</s> 96 bytes
Optimizer
fonte
Se bem entendi, as formas 1,2,3 são ampliadas 2x, assim que a linha inferior em 2 devem ser feitas de 4 undescores, não 3.
edc65
@ edc65 As formas nos exemplos são perfeitamente dimensionadas. Se você está falando sobre a parte Construção, sim, isso é ampliado e há 3 sublinhados para que o número da aresta ocupe o 4º lugar
Otimizador
Mas não há números de arestas na forma 2 (na parte de construção, sim). A parte inferior da forma 2 deve ser igual ao fundo de forma 1.
edc65
@ edc65 Oh, aí! Fixo!
Optimizer
3
Eu li o título como "flocos de neve" e nem percebi o título real até você chamar a atenção para a diferença.
Mbomb007

Respostas:

4

CJam, 144 bytes

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*

Nova linha adicionada para evitar a rolagem. Experimente online

O programa funciona em várias etapas:

  1. O fractal inicial (ordem 1) é codificado como uma sequência de 7 ângulos (conceitualmente, múltiplos de 60 °) representando a direção do movimento
  2. O fractal é "aplicado" a um segmento horizontal (ordem 0 fractal) N vezes para gerar todos os "movimentos" na ordem N fractal
  3. A partir de [0 0], os movimentos são traduzidos em uma sequência de pontos com coordenadas [xy]
  4. Cada segmento (par de pontos) é convertido em 1 ou 2 trigêmeos [xyc], representando o caracter c nas coordenadas x, y
  5. O retângulo delimitador é determinado, as coordenadas são ajustadas e uma matriz de espaços é gerada
  6. Para cada trigêmeo, o caractere c é colocado na posição x, y na matriz e a matriz final é ajustada para a saída
aditsu
fonte
Esta resposta é longa o suficiente para se beneficiar da codificação de bytes: goo.gl/D1tMoc
Dennis
@ Dennis Não sei se acabei de jogar golfe ... e por que você colocou isso em um bloco?
Aditsu
Não tenho muita certeza ... Sua resposta é bastante impressionante. Passei um dia inteiro tentando fazer isso direito.
Dennis
@Dennis Obrigado; btw, você acha que geralmente é bom usar caracteres não-imprimíveis / controle? Eu costumo tentar evitá-los
aditsu
Se eu puder evitá-los sem aumentar a contagem de bytes, eu o faço. Mas mais curto é mais curto. : P Em casos como este em que comprimo o próprio código, em vez de uma string ou matriz, geralmente incluo as duas versões na resposta.
Dennis
16

Python 2, 428 411 388 bytes

Este foi bem complicado. Os padrões não mantêm suas proporções após cada etapa, o que significa que é muito difícil produzir processualmente uma imagem de seu antecessor. O que esse código faz, embora seja bastante ilegível depois de um intenso golfe matemático, é realmente traçar a linha do início ao fim usando a Dfunção recursivamente definida .

O tamanho também era um problema, e acabei começando no meio de um 5*3**nquadrado de lado e cortando as coisas depois, embora, se eu puder pensar em uma maneira melhor de calcular o tamanho, eu possa mudá-lo.

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
fonte
Uau, isso é incrível. Quer tentar a AAoD # 1?
Optimizer
r=[s*[" "]for i in range(s)]-> r=[[" "]*s]*s]raspa alguns bytes #
sirpercival
11
@sirpercival infelizmente isso não vai funcionar por causa de como *repete objetos mutáveis .
grc 21/05
oh, certo, eu esqueci #
sirpercival 21/15/16
Você pode salvar alguns bytes incorporando l, alternando print'\n'.join()para impressão dentro de um loop for, usando return[...][t]+x,e removendo os parênteses (t%2). Além disso, você pode usar min(c.find('\\')%s for c in S)se alterar o nome da lista Spara que não substitua o valor inicial de s.
grc 21/05
12

JavaScript ( ES6 ), 356 362 370

Essa é difícil ...

Cada forma é armazenada como um caminho. Existem 6 blocos de construção básicos (3 + 3 para trás)

  • 0diagonal para cima, esquerda para baixo, para a direita ( 4para trás)
  • 1diagonal inferior esquerda para cima direita ( 5para trás)
  • 2horizontal da esquerda para a direita ( 6para trás)

Para cada um, há uma etapa de substituição a ser aplicada ao aumentar a ordem:

  • 0-> 0645001(para trás 4-> 5441024)
  • 1-> 2116501(para trás 5-> 5412556)
  • 2 -> 2160224(para trás 6-> 0664256)

valores pré-preenchidos noh matriz, mesmo que os elementos 4..6 possam ser obtidos de 0..2 usando

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

Para obter a forma para a ordem especificada, o caminho é construído na variável p, aplicando as substituições repetidamente. Então o loop principal itera na variável p e desenha a forma dentro da matriz g [], onde cada elemento é uma linha.
Começando na posição (0,0), cada índice pode se tornar negativo (índice y em pedidos altos). Evito que os índices y negativos mudem toda a matriz g sempre que encontrar um valor y negativo. Eu não me importo se o índice x se torna negativo, como nos índices negativos de JS são permitidos, apenas um pouco mais difícil de gerenciar.
Na última etapa, eu varro a matriz principal usando .map, mas para cada linha eu preciso usar um loop explícito para (;;) usando ab variável que contém o menor índice x alcançado (que será <0).
Noconsole.log Na versão, existe uma nova linha à mão, que pode ser facilmente transformada em uma nova linha posterior, trocando duas linhas, como na versão do snippet.

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

Snippet útil para testar (no 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
fonte
6

Haskell, 265 bytes

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

(Nota: no GHC antes da 7.10, você precisará adicionar import Control.Applicativeou substituir abs<$>por map abs$.)

Execute online no Ideone.com

f n :: Int -> IO ()desenha o nível da nserpente. O desenho é calculado na ordem de bitmap, e não ao longo da curva, o que permite que o algoritmo seja executado no espaço O (n) (ou seja, logarítmico no tamanho do desenho). Quase metade dos meus bytes são gastos computando qual retângulo desenhar!

Anders Kaseorg
fonte
Eu entrei e ele funciona agora! Agradável!
Optimizer
Acontece que isso anteriormente não foi executado no Ideone.com porque eu estava assumindo o Int de 64 bits. Corrigido agora (sacrificando 2 bytes).
Anders Kaseorg
Sua aprovação como a coisa de login só precisava meu id e-mail para confirmação ..
Optimizer
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

Parâmetro obtido na entrada padrão. Teste- me .

nutki
fonte
5

Haskell, 469 419 390 385 365 bytes

a função f :: Int-> IO () pega um número inteiro como entrada e imprime a serpente de fluxo

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
fonte
Isso produz 2 × números ampliados. Eu acho que a pergunta está pedindo figuras menores no topo, e apenas usei figuras 2 × ampliadas para explicar como a serpente é construída.
Anders Kaseorg
Você está certo. Eu o corrigi #
Damien
Você pode usar $na definição de ke substituir (!!)acom o (a!!)qual pode se livrar de alguns parênteses. Fora isso, você parece conhecer muitos truques sozinho. Nice
proud haskeller
4

C, 479 474 468 427 bytes

Acho que não há como derrotar os caras do Perl e do Haskell, mas como ainda não há submissão em 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));}

Para economizar espaço em uma chamada atoi (), o número de argumentos passados ​​para o programa é usado para o nível.

O programa é executado em O (n ^ 3) ou pior; primeiro, o caminho é calculado uma vez para encontrar as coordenadas mín / máx; depois, para cada par (x, y) é calculado uma vez para encontrar o caractere naquele local específico. Terrivelmente lento, mas economiza na administração de memória.

Exemplo executado em http://codepad.org/ZGc648Xi

Zevv
fonte
Use em X,Y,K,L,M,N,i,j,c;vez de int X,Y,K,L,M,N,i,j,c;e em main(l)vez devoid main(int l)
Spikatrix 23/05
Sim, obrigado, eu já raspei isso e um pouco mais, vou colocar uma nova versão.
Zevv 23/05
A saída na versão mais recente parece ser cortada e um pouco fora nas extremidades.
Optimizer
Carreguei o blob errado, este deve ficar bem.
Zevv 23/05
4

Python 2, 523 502 475 473 467 450 437 bytes

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, me custou umas 3 horas, mas foi divertido de fazer!

A idéia é dividir a tarefa em várias etapas:

  1. Calcule todas as arestas (codificadas como 0-5) em ordem de aparência (desde o início da cobra até o fim)
  2. Calcule a posição de cada uma das arestas (e salve os valores mínimo e máximo para x e y)
  3. Crie as strings em que consiste (e use os valores mínimos para compensar, para que não obtenham índices negativos)
  4. Imprimir as strings

Aqui está o código na forma não-destruída:

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

Edit: eu mudei o idioma para python 2, para ser compatível com a minha resposta para o número 3 (e também economiza mais 6 bytes)

Matty
fonte
Bom trabalho; uma simples melhoria que você poderia fazer seria mudar l.extend(x)para l+=x. Além disso, você provavelmente pode usar codegolf.stackexchange.com/questions/54/... em vez do .split()que você usa (eu fiz algo semelhante em minha resposta)
KSab
@KSab Obrigado, eu me sinto realmente estúpido agora para usarextend
Matty
0

Pari / GP, 395

Fazendo um loop sobre x, posições de caracteres y e calculando qual caractere imprimir. Tentativas moderadas de minimização, pontuadas com espaço em branco e comentários removidos.

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

Cada caractere é o primeiro ou o segundo de uma célula hexagonal. A localização da célula é um número complexo z dividido na base b = 2 + w com os dígitos 0, 1, w ^ 2, ..., w ^ 5, onde w = e ^ (2pi / 6) sexta raiz da unidade. Esses dígitos são mantidos como 1 a 7 distintos e, em seguida, são levados de alto a baixo através de uma tabela de estados para rotação líquida. Isso está no estilo do código do flownake de Ed Shouten (xytoi), mas apenas para rotação líquida, não transformando dígitos em um índice "N" ao longo do caminho. As extensões são relativas a uma origem 0 no centro da forma. Contanto que o limite não seja um ponto final, eles estão no meio de um hexágono de 2 caracteres e apenas 1 desses caracteres é necessário. Mas quando o início e / ou o fim da cobra são necessários 2 caracteres, o limite X é k = 0 início e k <3 final. Pari possui "quads" como o sqrt (-3), mas o mesmo pode ser feito com partes reais e imaginárias separadamente.

Kevin Ryde
fonte
11
Isso não satisfaz completamente as regras relativas a espaços em branco iniciais e finais.
Anders Kaseorg
Obrigado, eu alterei. Seu haskell me venceu por uma hora em um loop x, y fez isso. Deveria ter postado antes de esperar para ver se mais inspiração viria :-).
Kevin Ryde
Agora o fim da serpente é cortada para k = 0, 1, 2. (A matemática é irritante dessa forma-eu tive que lidar com isso também.)
Anders Kaseorg
Ah, querida, quando o ponto final é o máximo x. Hmm.
Kevin Ryde