Compito

Il compito è quello di affiancare i poligoni, data la configurazione del vertice.

punteggio

Il tuo punteggio è uguale al "livello di complessità" raggiunto dalla tua candidatura. I livelli di complessità sono cumulativi, il che significa che per raggiungere il n. 3 è necessario supportare anche il n. 1 e il n. 2.

Gli invii a un livello di complessità uguale si distinguono per il conteggio dei byte; vittorie più basse.

Ingresso

L'input è una stringa contenente una configurazione di vertice, che rappresenta una figura di vertice. Cioè, un elenco di numeri separati da punti, in cui ogni numero intero (n) rappresenta un normale n-gon, collegato da un vertice comune.

Devono essere supportate le seguenti configurazioni di vertici:

• 3.3.3.3.3.3
• 3.3.3.3.6
• 3.3.3.4.4 (nota che l'ordine si riflette nella figura del vertice, quindi il seguito differisce)
• 3.3.4.3.4
• 3.12.12
• 3.4.6.4
• 3.6.3.6
• 4.4.4.4
• 4.6.12
• 4.8.8
• 6.6.6

Output - Livello di complessità n. 1: Figura di vertice

A questo livello di complessità, l'output è un'immagine che mostra la figura del vertice corrispondente all'input dato.

L'input è preceduto da un Fper indicare che deve essere emessa la figura del vertice e non l'intera piastrellatura.

Ad esempio F3.6.3.6fornisce questa figura di vertice:

Output - Livello di complessità n. 2: piastrellatura

A questo livello di complessità, l'output è un'immagine che mostra una piastrellatura uniforme usando la figura del vertice corrispondente all'input dato.

Ad esempio 3.6.3.6dà questa piastrellatura:

Non ci sono restrizioni sul colore o sul formato (salvo le lacune).

Output - Livello di complessità n. 3: doppia piastrellatura

A questo livello di complessità può essere formata una "doppia piastrellatura" da ciascuna piastrellatura. Ciò si ottiene disegnando linee dal centro di ciascun poligono al centro di ciascun poligono confinante.

La doppia piastrellatura viene specificata anteponendo l'input a V.

Ad esempio V3.6.3.6dà questa doppia piastrellatura (in rosso):

BBC BASIC

Rev 1 Codice golf, 655 caratteri ASCII, dimensione file tokenizzata 614

Alcuni importanti miglioramenti alla tabella dei dati, eseguendo l'hashing della stringa A.B..Nsu un numero (1*A+2*B+..n*N)+nprima di cercare e memorizzando solo un vettore di traduzione (l'altro è generato dal codice). Altre spiegazioni quando ho finito di giocare a golf.

t=PI*2DIMm(9)
c=0z=0INPUTz$
FORi=1TOLEN(z$)d%=VAL(MID$(z$,i))IFd%c+=1m(c)=d%i-=d%=12z+=c*d%
NEXTREPEATREADl,e,f
UNTILl=z+c
l=4-3*(m(3)MOD3=0)-8*(l=59)
DATA69,0,70,65,100,35,66,149,0,49,109,0,52,80,0,55,0,189,39,120,0,44,40,40,58,55,95,47,136,0,59,40,0
VDU23,23,3|
FORr=-9TO19FORs=-9TO9a=1+e*(r*2+s)-f*l*s/4b=1+f*(r*2+s)+e*l*s/4p=40q=0FORk=1TOm(c)/2FORj=1TOc
n=m(j)o=TAN(PI/3)IFe=109ANDn<>4o=1
w=-p*COS(t/n)-q*SIN(t/n)q=p*SIN(t/n)-q*COS(t/n)p=w
u=p:v=q
x=a:y=b
MOVEx,y
FORi=1TO14x+=u*2y+=v*2IFVAL(z$)DRAWx,y ELSEGCOL9LINEx-u-v/o,y-v+u/o,x-u+v/TAN(PI/n),y-v-u/TAN(PI/n)
w=v*COS(t/n)-u*SIN(t/n)u=v*SIN(t/n)+u*COS(t/n)v=w
NEXTNEXT
p=u:q=v
a=x:b=y
NEXTNEXTNEXT

Rev 0 Codice golf, 770 caratteri ASCII, dimensione file tokenizzata 728

Tutto quello che ho fatto qui è rimuovere commenti, spazi bianchi e virgolette non necessari e mettere tutto DATAsu una riga. C'è sicuramente spazio per più golf.

t=PI*2DIMm(9)
c=0INPUTz$
FORi=1TOLEN(z$)d%=VAL(MID$(z$,i))IFd%c+=1:m(c)=d%:i-=d%=12
NEXTREPEATREADl$,e,f,g,h
UNTILMID$(z$,1-(VAL(z$)=0))=l$
DATA3.3.3.3.3.3,240,0,120,70,3.3.3.3.6,200,70,40,210,3.3.3.4.4,80,0,40,150,3.3.4.3.4,-40,150,150,40,3.12.12,300,0,150,260,3.4.6.4,220,0,110,188,3.6.3.6,160,0,80,140,4.4.4.4,80,0,0,80,4.6.12,0,380,330,-190,4.8.8,272,0,136,136,6.6.6,240,0,120,70
VDU23,23,3|
FORr=-9TO19 FORs=0TO9a=1+e*r+g*s
b=1+f*r+h*s
p=40q=0FORk=1TOm(c)/2FORj=1TOc
n=m(j)o=TAN(PI/3):IFe=220ANDn<>4o=1
w=-p*COS(t/n)-q*SIN(t/n)q=p*SIN(t/n)-q*COS(t/n)p=w
u=p:v=q
x=a:y=b
MOVEx,y
FORi=1TO14x+=u*2y+=v*2IFVAL(z$)DRAWx,y ELSEGCOL9LINEx-u-v/o,y-v+u/o,x-u+v/TAN(PI/n),y-v-u/TAN(PI/n)
w=v*COS(t/n)-u*SIN(t/n)u=v*SIN(t/n)+u*COS(t/n)v=w
NEXTNEXT
p=u:q=v
a=x:b=y
NEXTNEXTNEXT

Spiegazione

Questa è una continuazione della mia precedente risposta di livello 1, ma ho deciso di pubblicarla separatamente perché è piuttosto lunga.

Livello 2

Ciò si ottiene traducendo i miei modelli "livello 1.5" dalla mia risposta precedente. I due vettori di traduzione per ogni piastrellatura sono codificati. Approfitto del fatto che un triangolo isoscele di base 80 e altezza 70 è un'ottima approssimazione di un triangolo equilatero e un triangolo rettangolo con vettore ipotenuso (56,56)ha una lunghezza ipotenusa molto vicina a 80.

Livello 3

Per tracciare i doppi, invece di tracciare un bordo del poligono, tracciamo un raggio dalla metà di quel bordo al centro del poligono. Questo è ad angolo retto rispetto al bordo e ha una lunghezza di 1/TAN/(PI/n)volte del vettore (u, v) che a sua volta è la metà del bordo.

Purtroppo, perché alcuni poligoni in tassellature 3.3.3.3.6e 3.4.6.4non sono tracciate in modo esplicito, non sarebbero tracciate se abbiamo fatto solo questo. Pertanto il raggio si estende anche verso l'esterno dal poligono. L'estensione verso l'esterno è controllata dalla variabile o.

Per impostazione predefinita l'estensione è sufficiente per raggiungere il centro di un triangolo, ma per 3.4.6.4questo deve essere estesa di più per disegnare i doppi dei quadrati che non sono tracciati esplicitamente. Pertanto, viene applicata un'estensione sufficiente per riempire i quadrati mancanti quando gli esagoni e i triangoli vengono tracciati esplicitamente, ma l'estensione normale viene applicata quando i quadrati vengono stampati esplicitamente, per evitare linee spurie nei triangoli adiacenti.

Ecco come si presentano senza le estensioni dei raggi. I fori nel modello doppio sono chiaramente visibili. L'output corretto è visibile nell'immagine principale nella parte inferiore della risposta

Codice commentato

Le differenze dalla mia risposta precedente sono indicate in linea

  t=PI*2                                          :REM constant Tau = PI*2

  DIMm(9)                                         :REM declare array for the numbers in the input
  c=0                                             :REM number of polygons in the list

  INPUTz$
  FORi=1TOLEN(z$)                                 :REM for each character in the input
    d%=VAL(MID$(z$,i))                            :REM use VAL to return the numeric value of the substring to the right and store to integer variable
    IF d% c+=1 :m(c)=d%: i-=d%=12                 :REM if the last character read was a number, d% contains it, otherwise 0. Advance c and store to m. If it is 12, increment i to skip a character.
  NEXT

  REM BLOCK OF NEW CODE to define vectors (e,f) and (g,h) for each possible tiling

  REPEAT
    READ l$,e,f,g,h                               :REM read an entire line of the data below
  UNTIL MID$(z$,1-(VAL(z$)=0))=l$                 :REM abort the loop when l$ coincides with the input. the MID$ strips off the 'V' from the input where necessary.

  DATA"3.3.3.3.3.3",240,0,120,70
  DATA"3.3.3.3.6",200,70,40,210
  DATA"3.3.3.4.4",80,0,40,150
  DATA"3.3.4.3.4",-40,150,150,40
  DATA"3.12.12",300,0,150,260
  DATA"3.4.6.4",220,0,110,188
  DATA"3.6.3.6",160,0,80,140
  DATA"4.4.4.4",80,0,0,80
  DATA"4.6.12",0,380,330,-190
  DATA"4.8.8",272,0,136,136
  DATA"6.6.6",240,0,120,70

  VDU23,23,3|                                           :REM change linewidth to 3 (default is 1)

  REM END BLOCK OF NEW CODE

  FORr=-9TO19 FORs=0TO9                                 :REM two new loops for translations

      a=1+e*r+g*s                                       :REM modified code for
      b=1+f*r+h*s                                       :REM coordinates to start drawing at


      p=40:q=0                                          :REM vector of first line

      FORk=1TOm(c)/2                                    :REM draw half as many vertex figures as there are sides on the last polygon in the list

        FORj=1TOc                                       :REM for each polygon on the list
          n=m(j)                                        :REM n=number of sides
          o=TAN(PI/3): IF e=220 AND n<>4 o=1            :REM new code for the spoke extension 1/o. 

          w=-p*COS(t/n)-q*SIN(t/n)                      :REM rotate the starting vector anticlockwise by the internal angle of the current polygon
          q=p*SIN(t/n)-q*COS(t/n)                       :REM to avoid overlapping the previous one, if any.
          p=w

          u=p:v=q                                       :REM make a local copy of the vector and coordinates
          x=a:y=b                                       :REM to avoid corruption of p,q,a,b during the drawing of the polygon
          MOVE x,y                                      :REM move the graphics cursor to the start without drawing
          FORi=1TO14                                    :REM do 14 iterations regardless of the number of sides on the polygon
            x+=u*2                                      :REM increment x and y by the vector representing the side
            y+=v*2                                      :REM the value is double (u,v) to facilitate drawing duals later

            REM if z$ begins with a numeric character, draw an edge. If not, change to red and draw a spoke.
            IFVAL(z$) DRAW x,y ELSE GCOL9: LINEx-u-v/o,y-v+u/o,x-u+v/TAN(PI/n),y-v-u/TAN(PI/n)             

            w=v*COS(t/n)-u*SIN(t/n)                     :REM rotate the vector clockwise
            u=v*SIN(t/n)+u*COS(t/n)                     :REM through the external angle of the polygon
            v=w
          NEXT                                          :REM draw next edge of the current polygon
        NEXT                                            :REM draw next polygon of the current vertex

        p=u:q=v                                         :REM once the vertex is finished, we will be two sides around the perimeter of the last polygon.
        a=x:b=y                                         :REM copy the position and direction data into p,q,a,b.
      NEXT                                              :REM draw next vertex figure

    NEXT                                                :REM close the two new translation loops
  NEXT

Produzione

Il programma esegue solo una piastrellatura o doppia per ogni corsa. Tuttavia traccia i doppi in rosso. Per risparmiare spazio, ho eseguito il programma due volte senza cancellare lo schermo per sovrapporre il doppio in cima alla normale piastrellatura.

matematica

Il livello 1 contiene i modelli di tessere di base che vengono ripetutamente stampati su un piano.

Il livello 2 esegue la piastrellatura.

Ci sono ancora 2 limiti che non sono riuscito a raggiungere. Sembrano richiedere la rotazione e la traduzione.

Livello 1: Figura di vertice (559 byte)

nGon[n_]:=
{ColorData[46,"ColorList"][[n]],Polygon@Switch[n,
3,{{0,0},{-1/2,.866},{-1,0},{0,0}},
4,{{0,0},{0,1},{-1,1},{-1,0},{0,0}},
6,Table[{Cos[i 2Pi/n],Sin[i 2Pi/n]}+{-.5,.866},{i,0,n}],
8,Table[1.31{Cos[i Pi/4],Sin[i Pi/4]}+{-0.5`,1.207},{i,1/2,9}],
_,Table[2{Cos[i 2Pi/n],Sin[i 2Pi/n]}+{-0.5176,1.932},{i,1/2,13}]]}
innerAngle[n_]:=180-360/n
g[{}]=0;
g[a_]:=-(Plus@@innerAngle/@a)

h[{{},__,out_}]:=out
h[{list_,angles_,out_}]:=(
z=GeometricTransformation[nGon[l=list[[1]]],RotationTransform[g[angles] Degree]];
h[{Rest@list,Append[angles,l],Append[out,z]}])

analisi

Row[Graphics[{EdgeForm[{Blue}], #}, 
      ImageSize -> 70] & @@ {h[{#, {}, {}}]} & /@ {{3, 3, 3, 3, 3, 
    3}, {3, 3, 3, 3, 6}, {3, 3, 3, 4, 4}, {3, 3, 4, 3, 4}, {3, 12, 
    12}, {3, 4, 6, 4}, {3, 6, 3, 6}, {4, 4, 4, 4}, {4, 6, 12}, {4, 8, 
    8}, {6, 6, 6}}]

Livello 2: piastrellatura (690 byte aggiuntivi)

Le regole restituiscono offset e rientri di affiancamento per ciascuna configurazione.

r è la funzione di base che genera i limiti.

pmostra il modello e la relativa piastrellatura. Gli spazi bianchi corrispondono a quelli non coperti dal modello.

rules={
{3,6,3,6}-> {2,3.47,0,0},
{4,4,4,4}-> {1,1,0,0},
{6,6,6}-> {3,2.6,1.5,0},
{3,3,3,3,3,3}-> {1.5,1.74,0,.9},
{3,3,3,3,6}-> {2,2.6,-0.4,1.8},

{4,6,12}->{4.2,4.9,0,2.5},
{3,3,4,3,4}-> {1.87,1.86,-.5,-0.5},
{4,8,8}-> {3.4,3.4,0,0},
{3,3,3,4,4}-> {2,1.87,.52,0},
{3,12,12}-> {3.82,6.73,0,0},
{3,4,6,4}-> {1.4,4.3,0(*1.375*)-1,-2.4}};


r[nGons_]:=
Module[{horizHop,vertHop,indent,downIndent},
{horizHop,vertHop,indent,downIndent}=(nGons/.rules);
Graphics[{EdgeForm[{Blue}],Table[GeometricTransformation[h[{#,{},{}}]&/@{nGons},
TranslationTransform[{
If[MemberQ[{{3,3,4,3,4},{3,3,3,3,6},{3,4,6,4}},nGons],indent *row,indent Boole[OddQ[row]]]+col horizHop,
If[MemberQ[{{3,3,4,3,4},{3,3,3,3,6},{3,4,6,4}},nGons],downIndent *col,downIndent Boole[OddQ[col]]]-row vertHop}]],
{col,0,5},{row,0,4}]},ImageSize-> 250]]

p[nGon_]:=Row[{Graphics[{EdgeForm[{Blue}],h[{nGon,{},{}}]},ImageSize->70],r@nGon}];

analisi

Piastrellatura triangolare

p[{3, 3, 3, 3, 3, 3}]

esagonale

p[{6, 6, 6}]

piazza

p[{4, 4, 4, 4}]

sconosciuto

p[{3, 3, 4, 3, 4}]

quadrato troncato

p[{4, 8, 8}]

trihexagonal

p[{3, 6, 3, 6}]

troncato esagonale

p[{3, 12, 12}]

Senza nome

p[{3, 3, 3, 3, 6}]

triangolare allungato

p[{3, 3, 3, 4, 4}]

Tetti per capire

R

Passo 1

Ecco i miei sforzi per costruire le piastrelle. La piastrellatura verrà dopo. Questo non convalida l'input, quindi gli invalidi disegneranno delle strane tessere. L'input viene digitato dopo la prima riga

i=as.numeric(unlist(strsplit(readline(),"[.]")))
e=c()
for(n in 1:length(i)){
    o=sum(c(0,180-360/i[1:n-1]))
    for(z in 1:i[n]){
        e=c(e,(360/i[n])*(z-1)+o)
    }
}
f=pi/180
plot(c(0,cumsum(sin(e*f))),c(0,cumsum(cos(e*f))),type="l")

Step # 1, # 2 & # 3: 1898

Finalmente ci siamo tornati. La maggior parte di questo è occupata dall'impostazione di offset e dalla gestione di casi speciali :). Modifica: il flag V per i dual è ora gestito

Il processo generale è:

• Prendi l'input e crea un elenco
• Crea un elenco di angoli per disegnare la tessera iniziale
• Calcola i centri di ciascun poligono sulla piastrella e sui vettori per separare i bordi
• Determina il set di tessere da disegnare e crea un elenco di offset angolari. Ad alcune tessere sono aggiunti poligoni aggiuntivi per facilitare il riempimento dei fori.
• Disegna le tessere
• Disegna i doppi

Probabilmente posso ancora giocare a golf un po 'di più.

##Get input (Enter by itself then type in the tile scheme)
i=strsplit(readline(),"[.]")[[1]]
## Run once i is set
q=0
if(substr(i[1],1,1)=="V"){q=1;i[1]=substr(i[1],2,9)}
i=as.numeric(i)
f=pi/180
e=x=y=q=p=c()
l=length(i)
d=1/(2*tan(pi/3))
g=1/(2*sin(pi/3))
for(n in 1:l){o=sum(c(0,180-360/i[1:n-1]))
r=1/(2*sin(pi/i[n]))
a=o+(180-360/i[n])/2
b=1/(2*tan(pi/i[n]))+d
for(z in 1:i[n]){x=c(x,r*sin(a*f))
y=c(y,r*cos(a*f))
q=c(q,b)
p=c(p,(360/i[n])*(z-1)+o-90)
e=c(e,(360/i[n])*(z-1)+o)}}
if(sum(i)==18&l==6){h=c(60,0);w=c(60,120)}
if(sum(i)==18&l==5){h=c(0,0,60);w=c(60,120,60)
e=c(e,0,-60,60,180,60,180)
x=c(x,g*sin(-30*f),g*sin(-30*f),g*sin(90*f))
y=c(y,1+g*cos(-30*f),1+g*cos(-30*f),1)
q=c(q,d+d,d+d,d+d)
p=c(p,-30,90,-30)}
if(sum(i)==17&l==5&sum(abs(diff(c(i,i[1]),1)))==2){h=c(0,0);w=c(90,60)}
if(sum(i)==17&l==5&sum(abs(diff(c(i,i[1]),1)))==4){h=c(0,30);w=c(270,300)}
if(sum(i)==17&l==4){h=c(0,30,-30);w=c(60,30,90)
e=c(e,150,120,210,300)
x=c(x,sin(150*f)+g*sin(90*f),sin(150*f)+sin(210*f)/2)
y=c(y,cos(150*f)+(1/(2*cos(pi/3)))*cos(90*f),cos(150*f)+cos(210*f)/2)
q=c(q,1,1)
p=c(p,210,120)}
if(sum(i)==18&l==4){h=c(0,0);w=c(120,120)}
if(sum(i)==16&l==4){h=c(0,0);w=c(90,90)}
if(sum(i)==27&l==3){h=c(0,-30,0,30);w=c(60,90,120,150,180)}
if(sum(i)==22&l==3){h=c(0,-30,30,90,60,30)
w=c(90,150,120,90,60,30)
e=c(e,0,-30,-60,30,120,210,30,90,150)
q=q-d+1/(2*tan(pi/4));q[13]=q[17]=q[21]=q[21]+3}
if(sum(i)==20&l==3){h=c(0,-45,-90);w=c(90,0,45)}
if(sum(i)==18&l==3){h=c(0,60,0,-60);w=c(0,60,120,60)}
hx=sum(sin(h*f))
hy=sum(cos(h*f))
wx=sum(sin(w*f))
wy=sum(cos(w*f))
plot(0,0,type="n")
par(pin=c(5,5),usr=c(0,20,0,20))
for(c in -20:20){for(j in -20:20){lines(c((c*hx)+(j*wx)+0,(c*hx)+(j*wx)+cumsum(sin(e*f))),c((c*hy)+(j*wy)+0,(c*hy)+(j*wy)+cumsum(cos(e*f))),type="l")
if(q){for(n in 1:length(x)){lines(c((c*hx)+(j*wx)+x[n],(c*hx)+(j*wx)+x[n]+q[n]*sin(p[n]*f)),c((c*hy)+(j*wy)+y[n],(c*hy)+(j*wy)+y[n]+q[n]*cos(p[n]*f)),col="RED")}}}}

BBC BASIC

Scarica l'emulatore da http://www.bbcbasic.co.uk/bbcwin/bbcwin.html

Livello 1

Livello 1.5

Il livello 1.5 è la mia designazione, ma è una pietra miliare importante nel mio metodo.

La traduzione delle cifre dei vertici non porta sempre alla corretta piastrellatura. In alcuni casi mancano le righe.

La mia soluzione a questo è di aggirare il poligono più grande, disegnando la figura del vertice per ogni secondo vertice di quel poligono. Questa è una soluzione generale per tutti i casi. Si noti che il poligono più grande ha sempre un numero pari di lati e che la figura del vertice si alterna spesso in senso orario / antiorario mentre si procede intorno al poligono. Questo può essere visto più chiaramente con 4.6.12, ma è anche vero 4.8.8e 3.12.12: visto da un particolare 8 gon o 12 gon, i vertici alternati sono immagini speculari l'uno dell'altro. Questo è anche ciò che sta accadendo, un po 'meno ovviamente, con 3.3.3.4.4e 3.3.4.3.4: se visti da un particolare quadrato, i vertici alternati sono immagini speculari l'uno dell'altro.

L'algoritmo che uso per spostare 2 lati attorno al poligono è di fare sempre 14 iterazioni del ciclo di disegno del bordo, indipendentemente da quanti bordi ha il poligono. 8 è un fattore 16, quindi quando si disegnano gli ottagoni il cursore grafico finisce 16-14 = 2 vertici dietro il punto di partenza. 3- 4- 6- e 12 gon hanno tutti lati che sono fattori di 12, quindi il cursore grafico finisce 14-12 = 2 vertici davanti a dove è iniziato.

Le figure possono essere viste sotto. Domani spero di elaborare le traduzioni corrette per completare la piastrellatura. In tutti i casi vengono tracciate linee sufficienti per completare il livello 2 solo con traduzioni. In alcuni casi viene disegnato molto più del minimo richiesto, ma non c'è nessun problema con la sovrapposizione: le regole non dicono nulla sul disegno di linee solo una volta :-)

In generale, il poligono più grande è l'ultimo nell'elenco. Sfortunatamente esiste un caso in cui non è così: 3.4.6.4pertanto la figura disegnata in questo caso è centrata su un quadrato anziché su un esagono. Ci sono abbastanza linee per completare il livello 2 usando solo traduzioni, anche se ci saranno alcuni quadrati che non sono disegnati esplicitamente. Ciò presenterà alcuni problemi nel livello 3 (fortunatamente penso di sapere come risolverlo.) Allo stesso modo 3.3.3.3.6ci sono abbastanza linee per completare il livello 2 usando solo traduzioni, ma ci saranno alcuni triangoli che non sono disegnati esplicitamente.

Codice

Il codice per il livello 1.5 è commentato, solo il codice per il livello 1 è attivato. Ci sono quattro righe che iniziano con a REM. Rimuovi questi messaggi REMper attivare il livello 1.5.

  t=PI*2                                          :REM constant Tau = PI*2
  DIMm(9)                                         :REM declare array for the numbers in the input
  c=0                                             :REM number of polygons in the list

  INPUTz$
  FORi=1TOLEN(z$)                                 :REM for each character in the input
    d%=VAL(MID$(z$,i))                            :REM use VAL to return the numeric value of the substring to the right and store to integer variable
    IF d% c+=1 :m(c)=d%: i-=d%=12                 :REM if the last character read was a number, d% contains it, otherwise 0. Advance c and store to m. If it is 12, increment i to skip a character.
  NEXT

  FORi=1TOc PRINTm(i),:NEXT                       :REM parsing check for debugging.


  a=601:b=601                                     :REM coordinates to start drawing at
  p=40:q=0                                        :REM vector of first line

  REM FORk=1TOm(c)/2                              :REM draw half as many vertex figures as there are sides on the last polygon in the list

  FORj=1TOc                                       :REM for each polygon on the list
    n=m(j)                                        :REM n=number of sides

    w=-p*COS(t/n)-q*SIN(t/n)                      :REM rotate the starting vector anticlockwise by the internal angle of the current polygon
    q=p*SIN(t/n)-q*COS(t/n)                       :REM to avoid overlapping the previous one, if any.
    p=w

    u=p:v=q                                       :REM make a local copy of the vector and coordinates
    x=a:y=b                                       :REM to avoid corruption of p,q,a,b during the drawing of the polygon
    MOVE x,y                                      :REM move the graphics cursor to the start without drawing
    FORi=1TO14                                    :REM do 14 iterations regardless of the number of sides on the polygon
      x+=u*2                                      :REM increment x and y by the vector representing the side
      y+=v*2                                      :REM the value is double (u,v) to facilitate drawing duals later
      IFVAL(z$) DRAW x,y ELSE LINEx-u,y-v,x-u,y-v :REM if the first character of the input is a number, draw the side of the polygon. The ELSE part is unfinished and will be for drawing duals.
      w=v*COS(t/n)-u*SIN(t/n)                     :REM rotate the vector clockwise
      u=v*SIN(t/n)+u*COS(t/n)                     :REM through the external angle of the polygon
      v=w
    NEXT                                          :REM draw next edge of the current polygon
  NEXT                                            :REM draw next polygon of the current vertex

  REM p=u:q=v                                     :REM once the vertex is finished, we will be two sides around the perimeter of the last polygon.
  REM a=x:b=y                                     :REM copy the position and direction data into p,q,a,b.
  REM NEXT                                        :REM draw next vertex figure

Livelli 2 e 3

Vedi la mia altra risposta.