introduzione

In geometria, la curva di Peano è il primo esempio di una curva di riempimento dello spazio scoperta da Giuseppe Peano nel 1890. La curva di Peano è una funzione suriettiva e continua dall'intervallo unitario al quadrato dell'unità, tuttavia non è iniettiva. Peano è stato motivato da un precedente risultato di Georg Cantor che questi due set hanno la stessa cardinalità. Per questo esempio, alcuni autori usano la frase "curva di Peano" per riferirsi più in generale a qualsiasi curva di riempimento dello spazio.

Sfida

Il programma accetta un input che è un numero intero ne genera un disegno che rappresenta l' niterazione della curva di Peano, a partire dal lato 2 mostrato nella parte più a sinistra di questa immagine:

Ingresso

Un numero intero n fornisce il numero di iterazione della curva di Peano. Opzionale, input aggiuntivo è descritto nella sezione bonus.

Produzione

Un disegno della niterazione della curva di Peano. Il disegno può essere sia arte ASCII sia un disegno "reale", a seconda di quale sia la più semplice o la più breve.

Regole

• L'input e l'output possono essere forniti in qualsiasi formato conveniente (scegli il formato più appropriato per la tua lingua / soluzione).
• Non è necessario gestire valori negativi o input non validi
• È accettabile un programma completo o una funzione.
• Se possibile, includi un collegamento a un ambiente di test online in modo che altre persone possano provare il tuo codice!
• Sono vietate le scappatoie standard .
• Si tratta di code-golf, quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

bonus

Dal momento che questa non dovrebbe essere una passeggiata nel parco (almeno nella maggior parte delle lingue che mi viene in mente), vengono assegnati punti bonus per quanto segue:

• -100 byte se il codice genera una gif della costruzione delle curve di Peano fino a n.
• -100 byte se il codice disegna una curva di riempimento dello spazio per qualsiasi forma rettangolare (la curva di Peano funziona solo per i quadrati, ovviamente). Si può presumere che l'input assume quindi la forma in n l wcui nha lo stesso significato di prima (il numero dell'iterazione), ma dove le wdiventa la lunghezza e la larghezza del rettangolo in cui disegnare la curva. Se l == wdiventa questa la normale curva di Peano.

Sono ammessi punteggi negativi (ma sono possibili ...).

modificare

Includere l'output del programma nella soluzione per n == 3 (l == w == 1).

Mathematica, punteggio 60-100-100 = -140

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

Funzione pura. Accetta ne {l, w}(larghezza e altezza) come input e fornisce un'immagine animata come output. Per prima cosa crea una curva Peano di n ordine con PeanoCurve. Poiché il caso l = w deve ancora creare una curva di Peano, capovolgiamo l'espressione al livello 3, in modo simile alla risposta di DavidC ; per l ≠ w , abbiamo solo Scalela curva al rettangolo. Questa curva si riempirà comunque di spazio, soddisfacendo il secondo bonus. Per il primo bonus, lo facciamo Animatesu tutte le dimensioni. Si noti che OP ha suggerito che ciò era sufficientemente diverso da quello di DavidC per giustificare la propria risposta. Il risultato per n = 3, = 1 è il seguente: l = w

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

Un elenco modificato manualmente in formato .LST. Tutte le righe finiscono con CR, inclusa l'ultima.

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

Ampliato e commentato

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

Esempio di output

Perl 6 , 117 byte

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

Provalo online!

0-indicizzati. Restituisce un array 2D di caratteri Unicode. L'idea di base è che per le righe inferiori, l'espressione

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

produce lo schema

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

Per le righe superiori, l'espressione è

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

Spiegazione

{ ... }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 byte

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

Provalo online!

restituisce una matrice booleana

|'yè una sintassi specifica di ngn / k. altri dialetti richiedono a :per creare un monadico di verbo ciascuno:|:'y

Wolfram Language 83 36 byte, (possibilmente -48 byte con bonus)

A partire dalla versione 11.1, PeanoCurve è integrato.

La mia presentazione originale e goffa ha sprecato molti byte su GeometricTransformationeReflectionTransform.

Questa versione molto ridotta è stata suggerita da alephalpha . Reverseera necessario orientare correttamente l'output.

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

Esempio 36 byte

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

indennità

Se questo si qualifica per il bonus di 100 pt, pesa 52 - 100 = -48 Il codice [5]non è stato conteggiato, solo la funzione pura.

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

BBC BASIC, 142 caratteri ASCII (130 byte tokenizzati)

Scarica l'interprete su http://www.bbcbasic.co.uk/bbcwin/download.html

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 byte

L'output viene specchiato in orizzontale.

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

Provalo online! (stampa l'HTML)

(
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 byte

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

La risposta BASIC di Port of @ Arnauld Atari. Ad uso, fare qualcosa di simile questo :

reset
f 3

Stax , 19 byte

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

Esegui ed esegui il debug

Uscita per 3:

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