Introducción

En geometría, la curva de Peano es el primer ejemplo de una curva de relleno de espacio que descubrió Giuseppe Peano en 1890. La curva de Peano es una función surjective, continua desde el intervalo de la unidad en el cuadrado de la unidad, sin embargo, no es inyectiva. Peano fue motivado por un resultado anterior de Georg Cantor de que estos dos conjuntos tienen la misma cardinalidad. Debido a este ejemplo, algunos autores usan la frase "curva de Peano" para referirse más generalmente a cualquier curva de relleno de espacio.

Desafío

El programa toma una entrada que es un número entero ny genera un dibujo que representa la niteración de la curva de Peano, comenzando desde el lado 2 que se muestra en la parte más a la izquierda de esta imagen:

Entrada

Un entero n da el número de iteración de la curva de Peano. Opcional, la entrada adicional se describe en la sección de bonos.

Salida

Un dibujo de la n iteración de la curva de Peano. El dibujo puede ser tanto un arte ASCII como un dibujo "real", lo que sea más fácil o más corto.

Reglas

• La entrada y la salida se pueden dar en cualquier formato conveniente (elija el formato más apropiado para su idioma / solución).
• No es necesario manejar valores negativos o entradas inválidas
• Un programa completo o una función son aceptables.
• Si es posible, incluya un enlace a un entorno de prueba en línea para que otras personas puedan probar su código.
• Lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

Bonos

Como esto no debería ser un paseo por el parque (al menos en la mayoría de los idiomas que se me ocurren), se otorgan puntos de bonificación por lo siguiente:

• -100 bytes si su código genera un gif de la construcción de las curvas de Peano hasta n.
• -100 bytes si su código dibuja una curva de relleno de espacio para cualquier forma rectangular (la curva de Peano solo funciona para cuadrados, obviamente). Puede suponer que la entrada toma la forma n l wdonde ntiene el mismo significado que antes (el número de la iteración), pero donde ly se wconvierte en la longitud y el ancho del rectángulo en el que se dibuja la curva. Si l == w, esto se convierte en la curva de Peano regular.

Se permiten puntajes negativos (pero son posibles ...).

Editar

Incluya la salida de su programa en la solución para n == 3 (l == w == 1).

Mathematica, puntaje 60-100-100 = -140

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

Pura función. Toma ny {l, w}(ancho y alto) como entrada, y da un gráfico animado como salida. En primer lugar, crea un n º orden curva de Peano con PeanoCurve. Como el caso l = w todavía necesita crear una curva de Peano, volteamos la expresión en el nivel 3, similar a la respuesta de DavidC ; para l ≠ w , simplemente Scalela curva al rectángulo. Esta curva seguirá llenando espacios, satisfaciendo la segunda bonificación. Para el primer bono, lo hacemos Animateen todos los tamaños. Tenga en cuenta que OP sugirió que esto era lo suficientemente diferente de DavidC para garantizar su propia respuesta. El resultado para n = 3, l = w = 1 es el siguiente:

GFA Básico 3,51 (Atari ST), 156 134 124 bytes

Una lista editada manualmente en formato .LST. Todas las líneas terminan con CR, incluida la última.

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

Ampliado y comentado

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

Salida de ejemplo

Perl 6 , 117 bytes

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

Pruébalo en línea!

0 indexado. Devuelve una matriz 2D de caracteres Unicode. La idea básica es que para las filas inferiores, la expresión

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

produce el patrón

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

Para las filas superiores, la expresión es

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

Explicación

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

Pruébalo en línea!

devuelve una matriz booleana

|'yes una sintaxis específica de ngn / k. otros dialectos requieren a :para hacer un verbo monádico cada uno|:'y

Wolfram Language 83 36 bytes (posiblemente -48 bytes con bonificación)

A partir de la versión 11.1, PeanoCurveestá incorporada.

Mi presentación original y torpe desperdició muchos bytes GeometricTransformationyReflectionTransform.

Alephalpha sugirió esta versión muy reducida . Reversefue necesario para orientar la salida correctamente.

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

Ejemplo 36 bytes

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

Prima

Si esto califica para la bonificación de 100 pt, pesa 52-100 = -48. El código [5]no se contó, solo la función pura.

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

BBC BASIC, 142 caracteres ASCII (130 bytes tokenizados)

Descargue el intérprete en 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 bytes

La salida se refleja horizontalmente.

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

Pruébalo en línea! (imprime el 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 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

Puerto de la respuesta BÁSICA de Atari de @ Arnauld. Para usar, haga algo como esto :

reset
f 3

Stax , 19 bytes

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

Ejecutar y depurarlo

Salida para 3:

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