Un Flow Snake, noto anche come curva di Gosper , è una curva frattale, che cresce esponenzialmente in dimensioni con ogni ordine / iterazione di un semplice processo. Di seguito sono riportati i dettagli sulla costruzione e alcuni esempi per vari ordini:

Ordina 1 Flow Snake :

____
\__ \
__/

Ordina 2 Flow Snake :

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

Ordina 3 Flow Snake :

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

Costruzione

Considera l'ordine 1 Flow Snake da costruire di un percorso contenente 7 spigoli e 8 vertici (etichettati di seguito. Ingrandito per fattibilità):

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

Ora per ogni ordine successivo, è sufficiente sostituire i bordi con una versione ruotata di questo modello di ordine 1 originale. Utilizzare le seguenti 3 regole per sostituire i bordi:

1 Per un bordo orizzontale, sostituirlo con la forma originale così com'è:

________
\       \
 \____   \
     /
____/

2 Per un /bordo ( 12nella costruzione sopra), sostituirlo con la seguente versione ruotata:

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

3 Per un \bordo ( 34e 67sopra), sostituirlo con la seguente versione ruotata:

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

Quindi, ad esempio, apparirà l'ordine 2 con i vertici dall'ordine 1 etichettati

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

Ora per qualsiasi ordine superiore, devi semplicemente suddividere il livello corrente in bordi di lunghezze 1 /, 1 \o 2_ e ripetere il processo. Si noti che anche dopo la sostituzione, i vertici comuni tra due bordi consecutivi continuano a coincidere.

Sfida

• Devi scrivere una funzione di un programma completo che riceve un singolo intero Ntramite STDIN / ARGV / argomento della funzione o l'equivalente più vicino e stampa l'ordineN Flow Snake su STDOUT.
• L'intero di input è sempre maggiore di 0 .
• Non dovrebbero esserci spazi iniziali che non fanno parte del modello.
• Non dovrebbero esserci spazi finali o spazi finali sufficienti per riempire il motivo per riempire completamente il rettangolo di delimitazione minimo.
• Il trascinamento di newline è facoltativo.

Fatti divertenti

• Flow Snakes è un gioco di parole di Snow Flakes, che questo schema ricorda per l'ordine 2 e superiori
• Flow e Snakes svolgono effettivamente un ruolo nel pattern poiché il pattern è costituito da un singolo percorso che scorre attraverso.
• Se notate attentamente, il modello di ordine 2 (e anche superiore) comprende rotazioni di modello di ordine 1 imperniate sul vertice comune del bordo corrente e del bordo precedente.
• Esiste una variante non ASCII di Flow Snakes che può essere trovata qui e in diverse altre posizioni.

Questo è code-golf quindi il codice più breve in byte vince!

Classifica

Il primo post della serie genera una classifica.

Per assicurarti che le tue risposte vengano visualizzate, inizia ogni risposta con un titolo, utilizzando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

# Ruby, <s>104</s> <s>101</s> 96 bytes

CJam, 144 byte

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*

Newline aggiunto per evitare lo scorrimento. Provalo online

Il programma funziona in diversi passaggi:

1. Il frattale iniziale (ordine 1) è codificato come una sequenza di 7 angoli (concettualmente, multipli di 60 °) che rappresentano la direzione del movimento
2. Il frattale viene "applicato" a un segmento orizzontale (ordine 0 frattale) N volte per generare tutti i "movimenti" nell'ordine N frattale
3. A partire da [0 0], i movimenti sono tradotti in una sequenza di punti con coordinate [xy]
4. Ogni segmento (coppia di punti) viene convertito in 1 o 2 terzine [xyc], che rappresentano il carattere c in corrispondenza delle coordinate x, y
5. Viene determinato il rettangolo di delimitazione, le coordinate vengono regolate e viene generata una matrice di spazi
6. Per ogni tripletta, il carattere c viene posizionato nella posizione x, y nella matrice e la matrice finale viene regolata per l'output

Python 2, 428 411 388 byte

Questo è stato piuttosto complicato. I modelli non mantengono i loro rapporti dopo ogni passaggio, il che significa che è molto difficile produrre proceduralmente un'immagine dal suo predecessore. Ciò che fa questo codice, sebbene sia piuttosto illeggibile dopo un intenso gioco di golf in matematica, è in realtà tracciare la linea dall'inizio alla fine usando il metodo ricorsivamente definitoD funzione .

Anche la dimensione era un problema, e ho finito per iniziare nel mezzo di un 5*3**nquadrato laterale e ritagliare le cose in seguito, anche se se potessi pensare a un modo migliore per calcolare la dimensione, potrei cambiarlo.

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

È difficile ...

Ogni forma è memorizzata come percorso. Ci sono 6 blocchi base (3 + 3 indietro)

• 0diagonale in alto a sinistra in basso a destra ( 4indietro)
• 1diagonale in basso da sinistra a su a destra ( 5indietro)
• 2orizzontale da sinistra a destra ( 6indietro)

Per ognuno, c'è un passaggio di sostituzione da applicare quando si aumenta l'ordine:

• 0-> 0645001(indietro 4-> 5441024)
• 1-> 2116501(indietro 5-> 5412556)
• 2-> 2160224(indietro 6-> 0664256)

valori precompilati hnell'array, anche se gli elementi 4..6 possono essere ottenuti da 0..2 utilizzando

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

Per ottenere la forma per un determinato ordine, il percorso viene creato nella variabile p applicando ripetutamente le sostituzioni. Quindi il ciclo principale scorre sulla variabile p e disegna la forma all'interno dell'array g [], dove ogni elemento è una riga. nella versione è disponibile una nuova riga iniziale, che può essere facilmente creata una riga finale trascinata scambiando 2 righe, come nella versione dello snippet.
A partire dalla posizione (0,0), ciascun indice può diventare negativo (indice y ad ordini elevati). Evito che gli indici y negativi spostino tutto l'array g ogni volta che trovo un valore y negativo. Non mi importa se l'indice x diventa negativo, come in JS sono consentiti indici negativi, solo un po 'più difficile da gestire.
Nell'ultimo passaggio, eseguo la scansione dell'array principale usando .map, ma per ogni riga devo usare un ciclo esplicito per (;;) usando la bvariabile che contiene l'indice x minimo raggiunto (che sarà <0).
Nelconsole.log

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

Handy snippet da testare (in 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 byte

(?)=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: su GHC prima del 7.10, dovrai aggiungere import Control.Applicativeo sostituire abs<$>con map abs$.)

Corri online su Ideone.com

f n :: Int -> IO ()disegna il nserpentone di livello . Il disegno viene calcolato in ordine bitmap anziché lungo la curva, il che consente l'esecuzione dell'algoritmo nello spazio O (n) (ovvero logaritmico nella dimensione del disegno). Quasi la metà dei miei byte sono spesi per calcolare quale rettangolo disegnare!

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

Parametro preso sull'input standard. Metti alla prova me .

Haskell, 469 419 390 385 365 byte

la funzione f :: Int-> IO () accetta un numero intero come input e stampa il serpente di flusso

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 byte

Non c'è modo di battere i ragazzi di Perl e Haskell, immagino, ma dato che non c'è ancora nessuna presentazione C qui:

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

Per risparmiare spazio su una chiamata atoi (), per il livello viene utilizzato il numero di argomenti passati al programma.

Il programma funziona in O (n ^ 3) o peggio; prima il percorso viene calcolato una volta per trovare le coordinate min / max, quindi per ciascuna coppia (x, y) viene calcolato una volta per trovare il carattere in quella posizione specifica. Terribilmente lento, ma risparmia sull'amministrazione della memoria.

Esempio eseguito su http://codepad.org/ZGc648Xi

Python 2, 523 502 475 473 467 450 437 byte

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, mi è costato circa 3 ore, ma è stato divertente!

L'idea è di dividere l'attività in più passaggi:

1. Calcola tutti i bordi (codificati come 0-5) in ordine di apparizione (quindi dall'inizio del serpente alla fine)
2. Calcola la posizione per ciascuno dei bordi (e salva i valori minimo e massimo per xey)
3. Costruisci le stringhe in cui è composto (e usa i valori min per compensare, in modo da non ottenere indici negativi)
4. Stampa le stringhe

Ecco il codice in forma non golfata:

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

Modificare: ho cambiato la lingua in python 2, per essere compatibile con la mia risposta per # 3 (e salva anche altri 6 byte)

Pari / GP, 395

Ripassa ciclicamente le posizioni dei caratteri x, y e calcola quale carattere stampare. Moderati tentativi di minimizzazione, segnati con spazi bianchi e commenti eliminati.

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

Ogni carattere è il primo o il secondo di una cella esagonale. Una posizione di cella è un numero complesso z diviso in base b = 2 + w con cifre 0, 1, w ^ 2, ..., w ^ 5, dove w = e ^ (2pi / 6) sesta radice dell'unità. Queste cifre vengono mantenute esattamente come da 1 a 7, quindi portate da alto a basso attraverso una tabella di stato per la rotazione della rete. Questo è nello stile di codice flownake di Ed Shouten (xytoi) ma solo per la rotazione della rete, non facendo cifre in un indice "N" lungo il percorso. Le estensioni sono relative a un'origine 0 al centro della forma. Fintanto che il limite non è un endpoint, questi sono al centro di un esagono di 2 caratteri e solo 1 di questi caratteri è necessario. Ma quando l'inizio e / o la fine del serpente sono necessari i caratteri X limit 2, che è k = 0 inizio e k <3 fine. Pari ha "quad" come sqrt (-3) incorporato, ma lo stesso può essere fatto separatamente con parti reali e immaginarie.