Genera un Koch Snowflake

Un fiocco di neve di Koch è un triangolo che per ciascuno di essi nviene aggiunto un altro punto equilatero nel mezzo di ciascun lato: http://en.wikipedia.org/wiki/Koch_snowflake#Properties

Avevamo già una sfida Koch Snowflake per complessità kolmogrovn=4 . La nuova sfida è quella di disegnare un fiocco di neve Koch con qualsiasi ntra 1e 10.

Regole

I fiocchi di neve potrebbero non essere codificati nel programma o nei file: devono essere generati dal programma.

Il tuo programma deve supportare tutte le dimensioni ntra 1 e 10.

Il numero di lati deve essere inserito dall'utente tramite std-in.

È necessario stampare una rappresentazione grafica del fiocco di neve sullo schermo.

Fiocchi di neve di esempio Koch con nuguale a 1, 2, 3 e 4 (linee verdi solo per chiarezza, non riprodurli):

In caso di pareggio, vince il programma con il maggior numero di voti positivi (contest pop).

Mathematica 72

Region@Line@AnglePath[Nest[Join@@({#,1,4,1}&/@#)&,{4,4,4},Input[]-1]π/3]

n = 3

Grazie per alephalpha.

MATLAB, 119 115

In una svolta insolita di eventi, ho scoperto che questo programma funzionava davvero meglio mentre lo giocavo a golf. Innanzitutto, è diventato molto più veloce grazie alla vettorializzazione. Ora mostra un utile messaggio che ~n:~ricorda all'utente quale quantità inserire!

Newline non fanno parte del programma.

x=exp(i*pi/3);
o='~n:~';
P=x.^o;
for l=2:input(o);
P=[kron(P(1:end-1),~~o)+kron(diff(P)/3,[0 1 1+1/x 2]) 1];
end;
plot(P)

n = 9:

oè una stringa arbitraria che è uguale al [0 2 4 0]modulo 6. e ^{iπ / 3} elevato a questi poteri fornisce i vertici di un triangolo equilatero nel piano complesso. Il primo kronviene utilizzato per creare una copia dell'elenco dei punti con ognuno duplicato 4 volte. ~~oè il modo conveniente per ottenere un vettore di 4. In secondo luogo diff(P)trova il vettore tra ogni coppia di punti consecutivi. I multipli di questo vettore (0, 1/3, (1 + e ^{-iπ / 3} ) / 3 e 2/3) vengono aggiunti a ciascuno dei vecchi punti.

T-SQL: 686 (esclusa la formattazione)

Per SQL Server 2012+.

Anche se questo non sarà mai un contendente, ho dovuto vedere se potevo farlo in T-SQL. Andato per l'approccio di iniziare con i tre bordi iniziali, quindi ricorrere attraverso ciascun bordo e sostituirli con 4 bordi per ogni livello. Infine, unendo il tutto in un'unica geometria per il livello specificato per @i

DECLARE @i INT=8,@ FLOAT=0,@l FLOAT=9;
WITH R AS(
    SELECT sX,sY,eX,eY,@l l,B,1i
    FROM(VALUES(@,@,@l,@,0),(@l,@,@l/2,SQRT(@l*@l-(@l/2)*(@l/2)),-120),(@l/2,SQRT(@l*@l-(@l/2)*(@l/2)),@,@,-240))a(sX,sY,eX,eY,B)
    UNION ALL
    SELECT a.sX,a.sY,a.eX,a.eY,l/3,a.B,i+1
    FROM R 
        CROSS APPLY(VALUES(sX,sY,sX+(eX-sX)/3,sY+(eY-sY)/3,sX+((eX-sX)/3)*2,sY+((eY-sY)/3)*2))x(x1,y1,x2,y2,x3,y3)
        CROSS APPLY(VALUES(x2+((l/3)*SIN(RADIANS(B-210.))),y2+((l/3)*COS(RADIANS(B-210.)))))n(x4,y4)
        CROSS APPLY(VALUES(x1,y1,x2,y2,B),
            (x3,y3,eX,eY,B),
            (x2,y2,x4,y4,B+60),
            (x4,y4,x3,y3,B-60)
        )a(sX,sY,eX,eY,B)
WHERE @i>i)
SELECT Geometry::UnionAggregate(Geometry::Parse(CONCAT('LINESTRING(',sX,' ',sY,',',eX,' ',eY,')')))
FROM R 
WHERE i=@i

LOGO: 95

to w:c ifelse:c=1[fd 2 lt 60][w:c-1 w:c-1 lt 180 w:c-1 w:c-1]end
to k:c repeat 3[w:c rt 180]end

Definisce la funzione kcon un parametro a livello singolo.

modificare

In questo editor online http://www.calormen.com/jslogo/ puoi aggiungere k readwordper usare il prompt per l'input, ma per qualche ragione questo comando non supporta l'abbreviazione standard rw.

La soluzione da 102 caratteri di seguito funziona in USB Log con input standard come specificato nella domanda. Tuttavia, il codice ha richiesto lievi modifiche poiché UCBLogo ha un parser strano. Richiede toed endessere in linee e spazi separati prima che :sia richiesto ma d'altra parte :sono opzionali.

to w c
ifelse c=1[fd 2 lt 60][w c-1 w c-1 lt 180 w c-1 w c-1]
end
to k c
repeat 3[w c rt 180]
end
k rw

BBC BASIC, 179

REV 1

INPUTn
z=FNt(500,470,0,0,3^n/9)END
DEFFNt(x,y,i,j,a)
LINEx-36*a,y-21*a,x+36*a,y-a*21PLOT85,x,y+a*42IFa FORj=-1TO1FORi=-1TO1z=FNt(x+24*a*i,y+j*14*a*(i*i*3-2),i,j,-j*a/3)NEXTNEXT
=0

Come prima, ma in bianco e nero, nelle versioni non golfate (ma aerodinamiche) e golfizzate. Non un vincitore, nonostante il fatto che farlo in questo modo eviti la necessità di un trattamento speciale per n = 1.

  INPUTn
        REM call function and throw return value away to z
  z=FNt(500,470,0,0,3^n/9)
  END

        REM x,y=centre of triangle. a=scale.
        REM loop variables i,j are only passed in order to make them local, not global.
  DEFFNt(x,y,i,j,a)

        REM first draw a line at the bottom of the triangle. PLOT85 then draws a filled triangle,
        REM using the specified point (top of the triangle) and the last two points visited (those used to draw the line.)
  LINEx-36*a,y-21*a,x+36*a,y-21*a
  PLOT85,x,y+42*a

        REM if the absolute magnitude of a is sufficient to be truthy, recurse to the next level.
        REM j determines if the triangle will be upright, inverted or (if j=0) infinitely small.
        REM i loops through the three triangles of each orientation, from left to right.
  IFa FORj=-1TO1 FORi=-1TO1:z=FNt(x+24*a*i,y+j*14*a*(i*i*3-2),i,j,-j*a/3):NEXT:NEXT

        REM return 0
  =0

REV 0

Secondo la risposta dell'OP a @xnor, i fiocchi di neve riempiti sono OK. Questa risposta è stata ispirata dal commento di xnor. I colori sono solo per divertimento e per mostrare il modo in cui è costruito. Prendi un triangolo (magenta in questo caso) e ricopri con 6 triangoli 1/3 della base.

  INPUTn
  z=FNt(500,470,n,1,0,0)
  END

  DEFFNt(x,y,n,o,i,a)
  a=3^n/22
  GCOLn
  MOVEx-36*a,y-o*21*a
  MOVEx+36*a,y-o*21*a
  PLOT85,x,y+o*42*a
  IFn>1FORi=-1TO1:z=FNt(x+24*a*i,y+14*a*(i*i*3-2),n-1,-1,i,a):z=FNt(x+24*a*i,y-14*a*(i*i*3-2),n-1,1,i,a)NEXT
  =0

Mathematica - 177

r[x_, y_] := Sequence[x, RotationTransform[π/3, x]@y, y]
Graphics@Polygon@Nest[
 ReplaceList[#, {___, x_, y_, ___}  Sequence[x,r[2 x/3 + y/3, 2 y/3 + x/3], y]
  ] &, {{0, 0}, {.5, √3/2}, {1, 0}, {0, 0}}, Input[]]

Clip bonus di variazione dell'angolo del pezzo intermedio

Python 3 - 139

Utilizza la libreria grafica tartaruga.

from turtle import*
b=int(input())
a=eval(("FR"*3)+".replace('F','FLFRFLF')"*~-b)
for j in a:fd(9/b*("G">j));rt(60*(2-3*("Q">j))*("K"<j))])

Python 3, 117 byte

from turtle import*
ht();n=int(input())-1
for c in eval("'101'.join("*n+"'0'*4"+")"*n):rt(60+180*(c<'1'));fd(99/3**n)

Metodo:

• La soluzione utilizza la grafica tartaruga di Python.
• n è input - 1
• A partire dalla stringa 0000uniamo ogni suo personaggio con 101 ntempi ripetutamente con il trucco di valutazione (grazie a @xnor per quello).
• Per ogni carattere nella stringa finale giriamo di 60 gradi a destra o 120 gradi a sinistra in base al valore del carattere ( 1o 0) e quindi spostiamo in avanti una lunghezza ( 99/3^n) che garantisce una dimensione simile per tutti n.
• L'ultimo 0nella stringa sarà inutile ma ridisegna la stessa linea che 0disegna la prima .

Esempio di output per input = 3:

R: 240 175

Perché sto cercando di aggirare R, ecco un'altra versione. Probabilmente ci saranno modi molto migliori per farlo e sono felice di ricevere suggerimenti. Quello che ho fatto sembra molto contorto.

n=readline();d=c(0,-120,-240);c=1;while(c<n){c=c+1;e=c();for(i in 1:length(d)){e=c(e,d[i],d[i]+60,d[i]-60,d[i])};d=e};f=pi/180;plot(cumsum(sin(d*f)),cumsum(cos(d*f)),type="l")

Saggia fwom youw gwave ...

Sapevo che avrei voluto provare a implementarlo in Befunge-98 usando TURT, ma non riuscivo a capire come procedere e mi ci sono seduto per diversi mesi. Ora, solo di recente, ho scoperto un modo per farlo senza usare l'auto-modifica! E così...

Befunge-98 con l'impronta digitale TURT, 103

;v;"TRUT"4(02-&:0\:0\1P>:3+:4`!*;
>j$;space makes me cry;^
^>1-:01-\:0\:01-\:0
0>I@
^>6a*L
^>ca*R
^>fF

Prendiamo prima alcuni dettagli di implementazione:

• Ho provato questo usando CCBI 2.1 , la cui implementazione di TURT (l'impronta digitale della tartaruga) fa I"stampare" l'immagine in un file SVG. Se lo esegui in CCBI senza l'argomento command --turt-line=PATH, verrà visualizzato come file CCBI_TURT.svg per impostazione predefinita. Questo è il più vicino che potrei venire a "stampare una rappresentazione grafica del fiocco di neve sullo schermo" con gli interpreti di Funge disponibili che ho trovato. Forse un giorno ci sarà un interprete migliore là fuori che ha un display grafico per la tartaruga, ma per ora ...
• Ci deve essere una nuova riga alla fine per CCBI per eseguirlo senza impiccagione (questo è incluso con il conteggio dei personaggi). Infatti, NO?

Fondamentalmente, funziona usando lo stack come una sorta di sistema L improvvisato ed espandendolo al volo. Ad ogni passaggio, se il numero in cima allo stack è:

• -2, quindi stampa e si arresta;
• -1, la tartaruga gira di 60 gradi in senso antiorario;
• 0, ruota di 120 gradi in senso orario;
• 1, si sposta in avanti (di 15 pixel qui, ma è possibile cambiarlo modificando fl'ultima riga);
• un numero n che è 2 o maggiore, quindi viene espanso nello stack in n-1, -1, n-1, 0, n-1, -1, n-1.

Per n = 10, questo processo richiede un tempo molto lungo (un paio di minuti sul mio sistema), e la conseguente SVG è ~ 10 MB e invisibili se visti nel browser, perché non è possibile regolare la dimensione del pennello utilizzando TURT. Sembra che IrfanView funzioni decentemente se hai i plugin giusti. Non conosco molto bene SVG, quindi non so quale sia il metodo preferito per visualizzare quei file (specialmente quando sono davvero grandi).

Ehi, almeno funziona - il che, considerando Befunge, è qualcosa di cui essere grati da solo.

Python 2, 127 byte

from turtle import *
def L(l,d=input()-1):
 for x in[1,-2,1,0]:[L(l,d-1),rt(60*x)] if d>0 else fd(l)
for i in'lol':lt(120);L(9)