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 código-golfe, 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

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

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

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>

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!

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 .

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]

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

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)

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.