Introdução

Em geometria, a curva de Peano é o primeiro exemplo de uma curva de preenchimento de espaço a ser descoberta por Giuseppe Peano em 1890. A curva de Peano é uma função contínua e subjetiva do intervalo da unidade ao quadrado da unidade, mas não é injetiva. Peano foi motivado por um resultado anterior de Georg Cantor de que esses dois sets têm a mesma cardinalidade. Devido a este exemplo, alguns autores usam a frase "curva Peano" para se referir de maneira mais geral a qualquer curva de preenchimento de espaço.

Desafio

O programa pega uma entrada que é um número inteiro ne gera um desenho representando a niteração da curva Peano, começando pelas laterais 2 mostradas na parte mais à esquerda desta imagem:

Entrada

Um número inteiro que nfornece o número de iteração da curva Peano. Entrada adicional opcional é descrita na seção de bônus.

Resultado

Um desenho da niteração da curva Peano. O desenho pode ser arte ASCII ou desenho "real", o que for mais fácil ou mais curto.

Regras

• A entrada e a saída podem ser fornecidas em qualquer formato conveniente (escolha o formato mais apropriado para o seu idioma / solução).
• Não há necessidade de lidar com valores negativos ou entrada inválida
• Um programa completo ou uma função são aceitáveis.
• Se possível, inclua um link para um ambiente de teste on-line para que outras pessoas possam experimentar seu código!
• As brechas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

Bónus

Como não deve ser um passeio no parque (pelo menos na maioria dos idiomas que consigo imaginar), pontos de bônus são concedidos pelo seguinte:

• -100 bytes se o seu código gerar um gif da construção das curvas Peano até n.
• -100 bytes se o seu código desenhar uma curva de preenchimento de espaço para qualquer forma retangular (a curva Peano funciona apenas para quadrados, obviamente). Você pode assumir que a entrada assume o formato n l wonde ntem o mesmo significado de antes (o número da iteração), mas onde le wse torna o comprimento e a largura do retângulo no qual desenhar a curva. Se l == w, isso se torna a curva Peano normal.

Pontuações negativas são permitidas (mas são possíveis ...).

Editar

Inclua a saída do seu programa na solução para n == 3 (l == w == 1).

Mathematica, pontuação 60 - 100 - 100 = -140

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

Função pura. Toma ne {l, w}(largura e altura) como entrada e fornece um gráfico animado como saída. Ele primeiro cria uma curva Peano de ordem n com PeanoCurve. Como o caso l = w ainda precisa criar uma curva Peano, alteramos a expressão no nível 3, semelhante à resposta de DavidC ; para l ≠ w , nós apenas Scalea curva para o retângulo. Essa curva ainda será preenchida, satisfazendo o segundo bônus. Para o primeiro bônus, nós cobrimos Animatetodos os tamanhos. Observe que o OP sugeriu que isso era suficientemente diferente do DavidC para garantir sua própria resposta. O resultado para n = 3, l = w = 1 é o seguinte:

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

Uma listagem editada manualmente no formato .LST. Todas as linhas terminam com CR, incluindo a ú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

Expandido e 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

Saída de exemplo

Perl 6 , 117 bytes

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

Experimente online!

Indexado a 0. Retorna uma matriz 2D de caracteres Unicode. A ideia básica é que, para linhas mais baixas, a expressão

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

produz o padrão

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

Para linhas superiores, a expressão é

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

Explicação

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

Experimente online!

retorna uma matriz booleana

|'yé uma sintaxe específica para ngn / k. outros dialetos requerem a :para tornar um verbo monádico de cada edição:|:'y

Wolfram Language 83 36 bytes, (possivelmente -48 bytes com bônus)

A partir da versão 11.1, PeanoCurveé um built-in.

Minha submissão original e desajeitada desperdiçou muitos bytes GeometricTransformationeReflectionTransform.

Esta versão muito reduzida foi sugerida pelos alefalpha . Reversefoi necessário para orientar a saída corretamente.

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

Exemplo 36 bytes

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

Bônus

Se isso se qualifica para o bônus de 100 pt, pesa 52 - 100 = -48 O código [5]não foi contado, apenas a função pura.

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

BBC BASIC, 142 caracteres ASCII (130 bytes tokenised)

Faça o download do intérprete em 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

A saída é espelhada 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>`)

Experimente online! (imprime o 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)

Logotipo, 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

Porto da resposta do Atari BASIC em @ Arnauld. Para usar, fazer algo parecido com isso :

reset
f 3

Stax , 19 bytes

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

Execute e depure

Saída para 3:

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