Einführung

In der Geometrie ist die Peano-Kurve das erste Beispiel für eine raumfüllende Kurve, die 1890 von Giuseppe Peano entdeckt wurde. Die Peano-Kurve ist eine surjektive, kontinuierliche Funktion vom Einheitsintervall bis zum Einheitsquadrat, jedoch nicht injektiv. Peano wurde von einem früheren Ergebnis von Georg Cantor motiviert, dass diese beiden Mengen die gleiche Kardinalität haben. Aufgrund dieses Beispiels verwenden einige Autoren den Ausdruck "Peano-Kurve", um sich allgemeiner auf jede raumfüllende Kurve zu beziehen.

Herausforderung

Das Programm nimmt eine Eingabe, die eine Ganzzahl ist n, und gibt eine Zeichnung aus, die die nIteration der Peano-Kurve darstellt, beginnend mit der im linken Teil dieses Bildes gezeigten Seite 2:

Eingang

Eine Ganzzahl n, die die Iterationsnummer der Peano-Kurve angibt. Optionale, zusätzliche Eingaben werden im Abschnitt Boni beschrieben.

Ausgabe

Eine Zeichnung der nIteration der Peano-Kurve. Die Zeichnung kann sowohl eine ASCII-Grafik als auch eine "echte" Zeichnung sein, je nachdem, was am einfachsten oder am kürzesten ist.

Regeln

• Die Ein- und Ausgabe kann in jedem beliebigen Format erfolgen (wählen Sie das für Ihre Sprache / Lösung am besten geeignete Format).
• Es müssen keine negativen Werte oder ungültige Eingaben verarbeitet werden
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig.
• Fügen Sie nach Möglichkeit einen Link zu einer Online-Testumgebung hinzu, damit andere Benutzer Ihren Code ausprobieren können!
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Boni

Da dies kein Spaziergang im Park sein sollte (zumindest in den meisten Sprachen, die mir einfallen), werden Bonuspunkte für Folgendes vergeben:

• -100 Bytes, wenn Ihr Code ein GIF der Konstruktion der Peano-Kurven bis erzeugt n.
• -100 Byte, wenn Ihr Code eine raumfüllende Kurve für eine rechteckige Form zeichnet (die Peano-Kurve funktioniert natürlich nur für Quadrate). Sie können davon ausgehen, dass die Eingabe dann die Form annimmt, n l win nder sie dieselbe Bedeutung wie zuvor hat (die Nummer der Iteration), aber wo lund win der Länge und Breite des Rechtecks, in dem die Kurve gezeichnet werden soll. Wenn l == w, wird dies zur regulären Peano-Kurve.

Negative Bewertungen sind erlaubt (aber möglich ...).

Bearbeiten

Bitte beziehen Sie die Ausgabe Ihres Programms in die Lösung für ein n == 3 (l == w == 1).

Mathematica, Punktzahl 60 - 100 - 100 = -140

Graphics[PeanoCurve@a~Reverse~3~Scale~#2]~Animate~{a,1,#,1}&

Funktion pur. Nimmt nund {l, w}(Breite und Höhe) als Eingabe und gibt eine animierte Grafik als Ausgabe aus. Es wird zunächst eine Peano-Kurve n- ter Ordnung mit erstellt PeanoCurve. Da der Fall l = w immer noch eine Peano-Kurve erzeugen muss, drehen wir den Ausdruck auf Stufe 3 um, ähnlich wie bei der Antwort von DavidC ; für l ≠ w geben wir nur Scaledie Kurve zum Rechteck an. Diese Kurve wird immer noch raumfüllend sein und den zweiten Bonus erfüllen. Für den ersten Bonus haben wir es einfach Animateüber alle Größen verteilt. Beachten Sie, dass OP vorschlug, dass sich dies ausreichend von DavidC unterscheidet, um seine eigene Antwort zu rechtfertigen. Das Ergebnis für n = 3, l = w = 1 ist wie folgt:

GFA Basic 3.51 (Atari ST), 156 134 124 Bytes

Eine manuell bearbeitete Liste im .LST-Format. Alle Zeilen enden mit CR, einschließlich der letzten.

PRO f(n)
DR "MA0,199"
p(n,90)
RET
PRO p(n,a)
I n
n=n-.5
DR "RT",a
p(n,-a)
DR "FD4"
p(n,a)
DR "FD4"
p(n,-a)
DR "LT",a
EN
RET

Erweitert und kommentiert

PROCEDURE f(n)      ! main procedure, taking the number 'n' of iterations
  DRAW "MA0,199"    !   move the pen to absolute position (0, 199)
  p(n,90)           !   initial call to 'p' with 'a' = +90
RETURN              ! end of procedure
PROCEDURE p(n,a)    ! recursive procedure taking 'n' and the angle 'a'
  IF n              !   if 'n' is not equal to 0:
    n=n-0.5         !     subtract 0.5 from 'n'
    DRAW "RT",a     !     right turn of 'a' degrees
    p(n,-a)         !     recursive call with '-a'
    DRAW "FD4"      !     move the pen 4 pixels forward
    p(n,a)          !     recursive call with 'a'
    DRAW "FD4"      !     move the pen 4 pixels forward
    p(n,-a)         !     recursive call with '-a'
    DRAW "LT",a     !     left turn of 'a' degrees
  ENDIF             !   end
RETURN              ! end of procedure

Beispielausgabe

Perl 6 , 117 Bytes

{map ->\y{|map {(((++$+y)%2+$++)%3**(y+$^v,*/3...*%3)??$^s[$++%2]!!'│')xx$_*3},<┌ ┐>,$_,<└ ┘>,1},^$_}o*R**3

Probieren Sie es online!

0-indiziert. Gibt ein 2D-Array mit Unicode-Zeichen zurück. Die Grundidee ist, dass für untere Zeilen der Ausdruck

(x + (x+y)%2) % (3 ** trailing_zeros_in_base3(3*(y+1)))

ergibt das Muster

|....||....||....||....||..  % 3
..||....||....||....||....|  % 3
|................||........  % 9
..||....||....||....||....|  % 3
|....||....||....||....||..  % 3
........||................|  % 9
|....||....||....||....||..  % 3
..||....||....||....||....|  % 3
|..........................  % 27

Für obere Zeilen lautet der Ausdruck

(x + (x+y+1)%2) % (3 ** trailing_zeros_in_base3(3*(y+3**n)))

Erläuterung

{ ... }o*R**3  # Feed $_ = 3^n into block

map ->\y{ ... },^$_  # Map y = 0..3^n-1

|map { ... },<┌ ┐>,$_,<└ ┘>,1  # Map pairs (('┌','┐'),3^n) for upper rows
                               # and (('└','┘'),1) for lower rows.
                               # Block takes items as s and v

( ... )xx$_*3  # Evaluate 3^(n+1) times, returning a list

 (++$+y)%2  # (x+y+1)%2 for upper rows, (x+y)%2 for lower rows
(         +$++)  # Add x
                   (y+$^v,*/3...*%3)  # Count trailing zeros of 3*(y+v) in base 3
                3**  # nth power of 3
               %  # Modulo
??$^s[$++%2]  # If there's a remainder yield chars in s alternately
!!'│'         # otherwise yield '│'

K (ngn / k) , 37 27 26 Bytes

{+y,(|'y:x,,~>+x),x}/1,&2*

Probieren Sie es online!

gibt eine boolesche Matrix zurück

|'yist syntaxspezifisch für ngn / k. andere Dialekte erfordern ein :, um ein einzelnes Verb monadisch zu machen:|:'y

Wolfram Language 83 36 Bytes (möglicherweise -48 Bytes mit Bonus)

Ab Version 11.1 PeanoCurveist ein eingebautes.

Meine ursprüngliche, unbeholfene Einreichung verschwendete viele Bytes auf GeometricTransformationundReflectionTransform.

Diese stark reduzierte Version wurde von Alephalpha vorgeschlagen . Reversewurde benötigt, um die Ausgabe richtig zu orientieren.

Graphics[Reverse/@#&/@PeanoCurve@#]&

Beispiel 36 Bytes

Graphics[Reverse/@#&/@PeanoCurve@#]&[3]

Bonus

Wenn dies für den 100-Punkte-Bonus qualifiziert ist, wiegt es 52 - 100 = -48. Der Code [5]wurde nicht gezählt, nur die reine Funktion.

Table[Graphics[Reverse/@#&/@PeanoCurve@#]&@k{k,#}&[5]

BBC BASIC, 142 ASCII-Zeichen (130 Bytes tokenisiert)

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

I.m:q=FNh(m,8,8,0)END
DEFFNh(n,x,y,i)
IFn F.i=0TO8q=FNh(n-1,x-i MOD3MOD2*2*x,y-i DIV3MOD2*2*y,i)DRAWBY(1AND36/2^i)*x,y*(12653/3^i MOD3-1)N.
=0

HTML + SVG + JS, 224 213 Bytes

Die Ausgabe wird horizontal gespiegelt.

n=>document.write(`<svg width=${w=3**n*9} height=${w}><path d="M1 ${(p=(n,z)=>n--&&(p(n,-z,a(a(p(n,-z,d+=z)),p(n,z))),d-=z))(n*2,r=d=x=y=1,a=_=>r+=`L${x+=~-(d&=3)%2*9} ${y+=(2-d)%2*9}`)&&r}"fill=#fff stroke=red>`)

Probieren Sie es online! (druckt das HTML aus)

(
n=>document.write(`<svg width=${w=3**n*9} height=${w}><path d="M1 ${(p=(n,z)=>n--&&(p(n,-z,a(a(p(n,-z,d+=z)),p(n,z))),d-=z))(n*2,r=d=x=y=1,a=_=>r+=`L${x+=~-(d&=3)%2*9} ${y+=(2-d)%2*9}`)&&r}"fill=#fff stroke=red>`)
)(3)

Logo, 89 Bytes

to p:n:a
if:n>0[rt:a
p:n-1 0-:a
fw 5
p:n-1:a
fw 5
p:n-1 0-:a
lt:a]end
to f:n
p:n*2 90
end

Port von @ Arnauld's Atari BASIC Antwort. Gebrauch, so etwas wie dies :

reset
f 3

Stax , 19 Bytes

∩▐j>♣←╙~◘∩╗╢\a╘─Ràô

Führen Sie es aus, und debuggen Sie es

Ausgabe für 3:

███ ███ ███ ███ ███ ███ ███ ███ ███ ███ ███ ███ ███ █
█ ███ ███ █ █ ███ ███ █ █ ███ ███ █ █ ███ ███ █ █ ███
█         █ █         █ █         █ █         █ █    
█ ███ ███ █ █ ███ ███ █ █ ███ ███ █ █ ███ ███ █ █ ███
███ █ █ ███ ███ █ █ ███ ███ █ █ ███ ███ █ █ ███ ███ █
    █ █         █ █         █ █         █ █         █
███ █ █ ███ ███ █ █ ███ ███ █ █ ███ ███ █ █ ███ ███ █
█ ███ ███ ███ ███ ███ ███ ███ ███ █ █ ███ ███ ███ ███
█                                 █ █                
█ ███ ███ ███ ███ ███ ███ ███ ███ █ █ ███ ███ ███ ███
███ █ █ ███ ███ █ █ ███ ███ █ █ ███ ███ █ █ ███ ███ █
    █ █         █ █         █ █         █ █         █
███ █ █ ███ ███ █ █ ███ ███ █ █ ███ ███ █ █ ███ ███ █
█ ███ ███ █ █ ███ ███ █ █ ███ ███ █ █ ███ ███ █ █ ███
█         █ █         █ █         █ █         █ █    
█ ███ ███ █ █ ███ ███ █ █ ███ ███ █ █ ███ ███ █ █ ███
███ ███ ███ ███ █ █ ███ ███ ███ ███ ███ ███ ███ ███ █
                █ █                                 █
███ ███ ███ ███ █ █ ███ ███ ███ ███ ███ ███ ███ ███ █
█ ███ ███ █ █ ███ ███ █ █ ███ ███ █ █ ███ ███ █ █ ███
█         █ █         █ █         █ █         █ █    
█ ███ ███ █ █ ███ ███ █ █ ███ ███ █ █ ███ ███ █ █ ███
███ █ █ ███ ███ █ █ ███ ███ █ █ ███ ███ █ █ ███ ███ █
    █ █         █ █         █ █         █ █         █
███ █ █ ███ ███ █ █ ███ ███ █ █ ███ ███ █ █ ███ ███ █
█ ███ ███ ███ ███ ███ ███ ███ ███ ███ ███ ███ ███ ███