Aufgabe

Die Aufgabe besteht darin, Polygone bei einer Scheitelpunktkonfiguration zu kacheln.

Wertung

Ihre Punktzahl entspricht dem "Komplexitätsgrad", den Ihre Einreichung erreicht. Die Komplexitätsstufen sind kumulativ, was bedeutet, dass Sie auch # 1 & # 2 unterstützen müssen, um # 3 zu erreichen.

Einreichungen mit gleicher Komplexität werden durch die Anzahl der Bytes unterschieden. niedrigste Gewinne.

Eingang

Die Eingabe ist eine Zeichenfolge, die eine Scheitelpunktkonfiguration enthält und eine Scheitelpunktfigur darstellt. Das heißt, eine durch Punkte getrennte Liste von ganzen Zahlen, wobei jede ganze Zahl (n) ein reguläres n-Gon darstellt, das durch einen gemeinsamen Scheitelpunkt verbunden ist.

Die folgenden Scheitelpunktkonfigurationen müssen unterstützt werden:

• 3.3.3.3.3.3
• 3.3.3.3.6
• 3.3.3.4.4 (Beachten Sie, dass sich die Reihenfolge in der Scheitelpunktzahl widerspiegelt, daher unterscheidet sich die folgende Reihenfolge.)
• 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

Ausgabe - Komplexitätsstufe 1: Scheitelpunktfigur

Bei dieser Komplexitätsstufe ist die Ausgabe ein Bild, das die Scheitelpunktzahl zeigt, die der gegebenen Eingabe entspricht.

Der Eingabe wird ein vorangestellt, Fum anzuzeigen, dass die Scheitelpunktzahl ausgegeben werden soll und nicht die vollständige Kachelung.

Zum Beispiel F3.6.3.6gibt diese Scheitelpunktzahl:

Ausgabe - Komplexitätsstufe 2: Kacheln

Bei dieser Komplexitätsstufe ist die Ausgabe ein Bild, das eine gleichmäßige Kachelung unter Verwendung der Scheitelpunktzahl zeigt, die der gegebenen Eingabe entspricht.

Zum Beispiel 3.6.3.6gibt diese Kachelung:

Es gibt keine Einschränkungen hinsichtlich Farbe oder Format (mit Ausnahme von Lücken).

Ausgabe - Komplexitätsstufe 3: Dual Tiling

Auf dieser Komplexitätsstufe kann aus jeder Kachelung eine "doppelte Kachelung" gebildet werden. Dies wird erreicht, indem Linien von der Mitte jedes Polygons zur Mitte jedes angrenzenden Polygons gezogen werden.

Die doppelte Kachelung wird angegeben, indem der Eingabe ein vorangestellt wird V.

Zum Beispiel V3.6.3.6gibt diese doppelte Kachelung (in rot):

BBC BASIC

Rev 1 Golfed Code, 655 ASCII-Zeichen, tokenisierte Dateigröße 614

Einige wichtige Verbesserungen an der Datentabelle, indem der String vor dem Nachschlagen A.B..Nauf eine Zahl (1*A+2*B+..n*N)+ngehasht und nur ein Übersetzungsvektor gespeichert wird (der andere wird durch Code generiert). Weitere Erklärungen, wenn ich mit dem Golfen fertig bin.

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 Golfed Code, 770 ASCII-Zeichen, tokenisierte Dateigröße 728

Alles, was ich hier getan habe, ist, Kommentare, unnötige Leerzeichen und Anführungszeichen zu entfernen und alles DATAin eine Zeile zu setzen. Es gibt sicherlich Platz für mehr 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

Erläuterung

Dies ist eine Fortsetzung meiner vorherigen Antwort auf Stufe 1, aber ich habe beschlossen, sie separat zu veröffentlichen, da sie ziemlich lang ist.

Level 2

Dies wird durch die Übersetzung meiner "Level 1.5" -Vorlagen aus meiner vorherigen Antwort erreicht. Die zwei Translationsvektoren für jede Kachelung sind fest codiert. Ich nutze die Tatsache, dass ein gleichschenkliges Dreieck der Basis 80 und der Höhe 70 eine sehr gute Annäherung an ein gleichseitiges Dreieck darstellt und ein rechtwinkliges Dreieck mit Hypotenusenvektor (56,56)eine Hypotenusenlänge sehr nahe bei 80 hat.

Stufe 3

Um die Duals zu zeichnen, zeichnen wir anstelle einer Kante des Polygons eine Speiche von der Mitte dieser Kante bis zur Mitte des Polygons. Dieser ist rechtwinklig zur Kante und hat die Länge des 1/TAN/(PI/n)Vektors (u, v), der wiederum halb so lang ist wie die Kante.

Unglücklicherweise werden bestimmte Polygone in Pflasterungen 3.3.3.3.6und 3.4.6.4nicht explizit aufgetragen sind, würden sie nicht aufgetragen werden , wenn wir dies nur tat. Daher erstreckt sich die Speiche auch vom Polygon nach außen. Die Ausdehnung nach außen wird von der Variablen gesteuert o.

Standardmäßig reicht die Erweiterung aus, um die Mitte eines Dreiecks zu erreichen. 3.4.6.4Sie muss jedoch weiter erweitert werden, um die Dualen der Quadrate zu zeichnen, die nicht explizit dargestellt werden. Wenn also Sechsecke und Dreiecke explizit dargestellt werden, wird eine ausreichende Erweiterung angewendet, um die fehlenden Quadrate auszufüllen. Die normale Erweiterung wird jedoch angewendet, wenn Quadrate explizit dargestellt werden, um störende Linien in den benachbarten Dreiecken zu vermeiden.

So sehen sie ohne die Speichenerweiterungen aus. Die Löcher im Doppelmuster sind deutlich zu erkennen. Die korrekte Ausgabe ist im Hauptbild am Ende der Antwort zu sehen

Kommentierter Code

Unterschiede zu meiner vorherigen Antwort werden inline angezeigt

  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

Ausgabe

Das Programm führt für jeden Lauf nur eine Kachelung oder eine Doppelkachelung durch. Die Duals werden jedoch rot dargestellt. Um Platz zu sparen, habe ich das Programm zweimal ausgeführt, ohne den Bildschirm zu löschen, um das Dual über die regulären Kacheln zu legen.

Mathematica

Stufe 1 enthält die grundlegenden Kachelvorlagen, die wiederholt gestempelt werden, um eine Ebene zu kacheln.

Level 2 macht die Kacheln.

Es gibt noch 2 Fliesen, die ich nicht erreichen konnte. Sie scheinen sowohl Rotation als auch Translation zu erfordern.

Stufe 1: Scheitelpunktzahl (559 Bytes)

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

Testen

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

Stufe 2: Kacheln (690 zusätzliche Bytes)

Die Regeln geben für jede Konfiguration Kachelversätze und Einrückungen zurück.

r ist die Grundfunktion, die die Fliesen ausgibt.

pzeigt die Vorlage und die jeweiligen Kacheln. Leerzeichen entsprechen denen, die nicht von der Vorlage abgedeckt werden.

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

Testen

Dreieckige Fliesen

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

sechseckig

p[{6, 6, 6}]

Platz

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

Unbekannt

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

abgeschnittenes Quadrat

p[{4, 8, 8}]

trihexagonal

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

sechseckig abgeschnitten

p[{3, 12, 12}]

unbenannt

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

länglich dreieckig

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

Tilings, um herauszufinden

R.

Schritt 1

Hier ist meine Anstrengung beim Bau der Fliesen. Fliesen kommen als nächstes. Dies validiert die Eingabe nicht, sodass Invaliden einige seltsame Kacheln zeichnen. Die Eingabe wird nach der ersten Zeile eingegeben

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

Schritt 1, 2 und 3: 1898

Endlich zurück. Das meiste davon wird mit dem Setzen von Offsets und dem Behandeln von Sonderfällen aufgenommen :). Bearbeiten: Das V-Flag für Duals wird jetzt behandelt

Der allgemeine Prozess ist:

• Nehmen Sie die Eingabe und erstellen Sie eine Liste
• Erstellen Sie eine Liste mit Winkeln, um die ursprüngliche Kachel zu zeichnen
• Berechnen Sie die Zentren jedes Polygons aus der Kachel und den Vektoren daraus, um die Kanten zu halbieren
• Bestimmen Sie den zu zeichnenden Kachelsatz und erstellen Sie eine Liste der Winkelversätze. Einige Kacheln sind mit zusätzlichen Polygonen versehen, um das Füllen von Löchern zu erleichtern.
• Zeichne die Kacheln
• Zeichne die Duals

Ich kann das wahrscheinlich noch ein bisschen mehr spielen.

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

Laden Sie den Emulator unter http://www.bbcbasic.co.uk/bbcwin/bbcwin.html herunter

Level 1

Stufe 1.5

Level 1.5 ist meine eigene Bezeichnung, aber es ist ein wichtiger Meilenstein in meiner Methode.

Das Übersetzen der Scheitelpunktzahlen führt nicht immer zur richtigen Kachelung. In einigen Fällen fehlen Zeilen.

Meine Lösung besteht darin, das größte Polygon zu umgehen und die Scheitelpunktzahl für jeden zweiten Scheitelpunkt dieses Polygons zu zeichnen. Dies ist eine allgemeine Lösung für alle Fälle. Beachten Sie, dass das größte Polygon immer eine gerade Anzahl von Seiten hat und die Scheitelpunktzahl beim Umrunden des Polygons häufig im Uhrzeigersinn / gegen den Uhrzeigersinn wechselt. Dies ist am deutlichsten zu erkennen 4.6.12, gilt aber auch für 4.8.8und 3.12.12: Bei Betrachtung von einem bestimmten 8-Gon oder 12-Gon sind abwechselnde Eckpunkte Spiegelbilder voneinander. Dies geschieht auch, etwas weniger offensichtlich, mit 3.3.3.4.4und 3.3.4.3.4: Von einem bestimmten Quadrat aus gesehen sind alternierende Eckpunkte Spiegelbilder voneinander.

Der Algorithmus, mit dem ich 2 Seiten um das Polygon bewege, besteht darin, immer 14 Iterationen der Kantenzeichnungsschleife durchzuführen, unabhängig davon, wie viele Kanten das Polygon hat. 8 ist ein Faktor von 16, daher endet der Grafikcursor beim Zeichnen von Achtecken mit 16-14 = 2 Eckpunkten hinter der Stelle, an der er begonnen hat. 3- 4- 6- und 12-gons haben alle Seiten, die Faktoren von 12 sind, so dass der Grafikcursor 14-12 = 2 Eckpunkte vor dem Startpunkt hat.

Die Zahlen sind unten zu sehen. Morgen hoffe ich, die richtigen Übersetzungen zu finden, um die Kacheln zu vervollständigen. In allen Fällen werden genügend Linien gezogen, um Level 2 nur mit Übersetzungen abzuschließen. In einigen Fällen wird viel mehr als das erforderliche Minimum gezeichnet, aber es gibt kein Problem mit Überlappungen: Die Regeln sagen nichts über das Zeichnen von Linien nur einmal aus :-)

Im Allgemeinen ist das größte Polygon das letzte in der Liste. Es gibt leider einen Fall, in dem dies nicht 3.4.6.4der Fall ist : Daher ist die in diesem Fall gezeichnete Figur eher auf einem Quadrat als auf einem Sechseck zentriert. Es gibt genügend Linien, um Level 2 nur mit Übersetzungen abzuschließen, obwohl es bestimmte Quadrate gibt, die nicht explizit gezeichnet werden. Dies wird einige Probleme in Level 3 aufwerfen (zum Glück denke ich, dass ich weiß, wie man das löst.) Ebenso 3.3.3.3.6gibt es genug Zeilen, um Level 2 nur mit Übersetzungen abzuschließen, aber es wird bestimmte Dreiecke geben, die nicht explizit gezeichnet werden.

Code

Der Code für Level 1.5 ist auskommentiert, nur der Code für Level 1 ist aktiviert. Es gibt vier Zeilen, die mit a beginnen REM. Entferne diese REMs, um Level 1.5 zu aktivieren.

  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

Level 2 und 3

Siehe meine andere Antwort.