Tâche

La tâche consiste à carreler des polygones, étant donné une configuration de sommets.

Notation

Votre score est égal au "niveau de complexité" atteint par votre soumission. Les niveaux de complexité sont cumulatifs, ce qui signifie que pour atteindre le numéro 3, vous devez également prendre en charge les numéros 1 et 2.

Les soumissions à niveau de complexité égal se distinguent par le nombre d'octets; victoires les plus faibles.

Contribution

L'entrée est une chaîne contenant une configuration de sommet, représentant une figure de sommet. C'est-à-dire une liste d'entiers séparés par des points, où chaque entier (n) représente un n-gon régulier, connecté par un sommet commun.

Les configurations de sommets suivantes doivent être prises en charge:

• 3.3.3.3.3.3
• 3.3.3.3.6
• 3.3.3.4.4 (notez que l'ordre est reflété dans la figure du sommet, donc ce qui suit diffère)
• 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

Sortie - Niveau de complexité # 1: Figure de sommet

À ce niveau de complexité, la sortie est une image montrant la figure de sommet correspondant à l'entrée donnée.

L'entrée est précédée d'un Fpour signifier que la figure de sommet doit être sortie, et non le pavage complet.

Par exemple, F3.6.3.6donne ce sommet:

Sortie - Niveau de complexité # 2: Mosaïque

A ce niveau de complexité, la sortie est une image montrant un pavage uniforme en utilisant la figure de sommet correspondant à l'entrée donnée.

Par exemple, 3.6.3.6donne ce pavage:

Il n'y a aucune restriction sur la couleur ou le format (sauf les failles).

Sortie - Niveau de complexité # 3: double pavage

À ce niveau de complexité, un «double carrelage» peut être formé à partir de chaque carrelage. Ceci est réalisé en traçant des lignes du centre de chaque polygone au centre de chaque polygone bordant.

Le double pavage est spécifié en ajoutant une entrée au début avec a V.

Par exemple, V3.6.3.6donne ce double pavage (en rouge):

BBC BASIC

Rev 1 Code Golfed, 655 caractères ASCII, taille de fichier à jetons 614

Quelques améliorations majeures à la table de données, en hachant la chaîne A.B..Nà un nombre (1*A+2*B+..n*N)+navant de rechercher, et en stockant un seul vecteur de traduction (l'autre est généré par le code.) Plus d'explications quand j'ai fini de jouer au 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

Rév 0 Code golfé, 770 caractères ASCII, taille de fichier à jetons 728

Tout ce que j'ai fait ici est de supprimer les commentaires, les espaces blancs et les guillemets inutiles, et de mettre tout cela DATAsur une seule ligne. Il y a certainement de la place pour plus de 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

Explication

Il s'agit d'une continuation de ma réponse précédente de niveau 1, mais j'ai décidé de la publier séparément car elle est plutôt longue.

Niveau 2

Ceci est réalisé par la traduction de mes modèles "niveau 1.5" de ma réponse précédente. Les deux vecteurs de traduction pour chaque pavage sont codés en dur. Je profite du fait qu'un triangle isocèle de base 80 et de hauteur 70 est une très bonne approximation d'un triangle équilatéral, et un triangle rectangle avec vecteur hypoténuse (56,56)a une longueur d'hypoténuse très proche de 80.

Niveau 3

Pour tracer les doubles, au lieu de tracer une arête du polygone, nous tracons un rayon du milieu de cette arête au centre du polygone. Ceci est perpendiculaire au bord et a une longueur de 1/TAN/(PI/n)temps du vecteur (u, v) qui à son tour est la moitié de la longueur du bord.

Malheureusement, parce que certains polygones dans les pavages 3.3.3.3.6et 3.4.6.4ne sont pas tracés explicitement, ils ne le seraient pas si nous ne faisions que cela. Par conséquent, le rayon s'étend également vers l'extérieur du polygone. L'extension vers l'extérieur est contrôlée par la variable o.

Par défaut, l'extension est suffisante pour atteindre le centre d'un triangle, mais pour 3.4.6.4cela, elle doit être étendue davantage afin de dessiner les doubles des carrés qui ne sont pas tracés explicitement. Ainsi, une extension suffisante pour remplir les carrés manquants est appliquée lorsque les hexagones et les triangles sont tracés explicitement, mais l'extension normale est appliquée lorsque les carrés sont tracés explicitement, pour éviter les lignes parasites dans les triangles adjacents.

Voici à quoi ils ressemblent sans les extensions de rayon. Les trous du double motif sont clairement visibles. La sortie correcte peut être vue dans l'image principale au bas de la réponse

Code commenté

Les différences par rapport à ma réponse précédente sont indiquées en ligne

  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

Production

Le programme effectue un seul pavage ou double pour chaque exécution. Cependant, il trace les duels en rouge. Pour économiser de l'espace, j'ai exécuté le programme deux fois sans effacer l'écran afin de superposer le double au-dessus du pavage normal.

Mathematica

Le niveau 1 contient les modèles de tuiles de base qui sont tamponnés à plusieurs reprises pour carreler un avion.

Le niveau 2 fait le carrelage.

Il y a encore 2 pavages que je n'ai pas pu obtenir. Ils semblent nécessiter une rotation ainsi qu'une translation.

Niveau 1: Vertex Figure (559 octets)

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

Essai

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

Niveau 2: mosaïque (690 octets supplémentaires)

Les règles renvoient des décalages de pavage et des retraits pour chaque configuration.

r est la fonction de base qui produit les pavages.

pmontre le modèle et le carrelage respectif. Les espaces blancs correspondent à ceux non couverts par le modèle.

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}];

Essai

Carrelage triangulaire

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

hexagonal

p[{6, 6, 6}]

carré

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

inconnue

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

carré tronqué

p[{4, 8, 8}]

trihexagonal

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

hexagonal tronqué

p[{3, 12, 12}]

anonyme

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

triangulaire allongé

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

Carrelages à comprendre

R

Étape 1

Voici mon effort pour construire les tuiles. Carrelage à venir ensuite. Cela ne valide pas l'entrée, donc les invalides dessineront des tuiles étranges. L'entrée est tapée après la première ligne

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

Étape # 1, # 2 & # 3: 1898

J'y suis enfin revenu. La majeure partie de cela est consacrée à la définition des décalages et à la gestion des cas spéciaux :). Edit: le drapeau V pour les duals est maintenant géré

Le processus général est le suivant:

• Prenez l'entrée et faites une liste
• Créez une liste d'angles pour dessiner la tuile initiale
• Calculer les centres de chaque polygone avec la tuile et les vecteurs pour diviser les bords
• Déterminez le jeu de tuiles en cours de dessin et faites une liste des décalages angulaires. Certaines tuiles ont des polygones supplémentaires ajoutés pour aider à remplir les trous.
• Dessinez les tuiles
• Dessinez les duels

Je peux probablement encore jouer au golf un peu plus.

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

Téléchargez l'émulateur sur http://www.bbcbasic.co.uk/bbcwin/bbcwin.html

Niveau 1

Niveau 1.5

Le niveau 1.5 est ma propre désignation, mais c'est une étape importante dans ma méthode.

La traduction des sommets ne conduit pas toujours au pavage correct. Dans certains cas, des lignes manquent.

Ma solution est de contourner le plus grand polygone, en dessinant la figure de sommet pour chaque deuxième sommet de ce polygone. Il s'agit d'une solution générale pour tous les cas. Notez que le plus grand polygone a toujours un nombre pair de côtés et que la figure du sommet alterne souvent dans le sens horaire / antihoraire lorsque vous faites le tour du polygone. Cela peut être vu plus clairement avec 4.6.12, mais c'est également vrai de 4.8.8et 3.12.12: lorsqu'ils sont vus à partir de n'importe quel 8-gon ou 12-gon particulier, les sommets alternés sont des images miroir les uns des autres. C'est aussi ce qui se passe, un peu moins évidemment, avec 3.3.3.4.4et 3.3.4.3.4: lorsqu'ils sont vus d'un carré particulier, les sommets alternés sont des images miroir les uns des autres.

L'algorithme que j'utilise pour déplacer 2 côtés autour du polygone consiste à toujours faire 14 itérations de la boucle de dessin des bords, quel que soit le nombre d'arêtes du polygone. 8 est un facteur de 16, donc lorsque vous dessinez des octogones, le curseur graphique se retrouve 16-14 = 2 sommets derrière l'endroit où il a commencé. 3- 4- 6- et 12-gons ont tous des côtés qui sont des facteurs de 12, de sorte que le curseur graphique finit par 14-12 = 2 sommets avant où il a commencé.

Les chiffres peuvent être vus ci-dessous. Demain, j'espère trouver les traductions correctes pour terminer le pavage. Dans tous les cas, suffisamment de lignes sont tracées pour terminer le niveau 2 avec des traductions uniquement. Dans certains cas, beaucoup plus que le minimum requis est dessiné, mais il n'y a pas de problème de chevauchement: les règles ne disent rien sur le dessin des lignes une seule fois :-)

En général, le plus grand polygone est le dernier de la liste. Il y a, malheureusement, un cas où ce n'est pas le cas: 3.4.6.4Par conséquent, la figure dessinée dans ce cas est centrée sur un carré plutôt que sur un hexagone. Il y a suffisamment de lignes pour terminer le niveau 2 en utilisant uniquement des traductions, bien qu'il y ait certains carrés qui ne sont pas dessinés explicitement. Cela posera des problèmes au niveau 3 (heureusement, je pense que je sais comment résoudre ce problème.) De même, 3.3.3.3.6il y a suffisamment de lignes pour terminer le niveau 2 en utilisant uniquement des traductions, mais il y aura certains triangles qui ne seront pas dessinés explicitement.

Code

Le code du niveau 1.5 est commenté, seul le code du niveau 1 est activé. Il y a quatre lignes commençant par un REM. Supprimez ces REMs pour activer le niveau 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

Niveaux 2 et 3

Voir mon autre réponse.