introduction

En géométrie, la courbe de Peano est le premier exemple de courbe de remplissage d'espace à être découvert par Giuseppe Peano en 1890. La courbe de Peano est une fonction surjective et continue de l'intervalle unitaire sur le carré unitaire, mais elle n'est pas injective. Peano était motivé par un résultat antérieur de Georg Cantor selon lequel ces deux sets avaient la même cardinalité. En raison de cet exemple, certains auteurs utilisent l'expression "courbe de Peano" pour se référer plus généralement à toute courbe de remplissage d'espace.

Défi

Le programme prend une entrée qui est un entier n, et sort un dessin représentant la nième itération de la courbe de Peano, en partant du côté 2 montré dans la partie la plus à gauche de cette image:

Contribution

Un entier ndonnant le numéro d'itération de la courbe de Peano. Des informations supplémentaires facultatives sont décrites dans la section bonus.

Production

Un dessin de la nième itération de la courbe de Peano. Le dessin peut être à la fois de l'art ASCII ou un "vrai" dessin, selon le plus simple ou le plus court.

Règles

• L'entrée et la sortie peuvent être données dans n'importe quel format pratique (choisissez le format le plus approprié pour votre langue / solution).
• Pas besoin de gérer des valeurs négatives ou des entrées invalides
• Un programme complet ou une fonction sont acceptables.
• Si possible, veuillez inclure un lien vers un environnement de test en ligne afin que d'autres personnes puissent essayer votre code!
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

Bonus

Comme cela ne devrait pas être une promenade dans le parc (du moins dans la plupart des langues auxquelles je pense), des points bonus sont accordés pour les éléments suivants:

• -100 octets si votre code génère un gif de la construction des courbes Peano jusqu'à n.
• -100 octets si votre code trace une courbe de remplissage d'espace pour n'importe quelle forme rectangulaire (la courbe de Peano ne fonctionne que pour les carrés, évidemment). Vous pouvez supposer que l'entrée prend alors la forme n l woù na la même signification qu'auparavant (le numéro de l'itération), mais où let wdevient la longueur et la largeur du rectangle dans lequel dessiner la courbe. Si l == w, cela devient la courbe de Peano régulière.

Les scores négatifs sont autorisés (mais sont-ils possibles ...).

Éditer

Veuillez inclure la sortie de votre programme dans la solution pour n == 3 (l == w == 1).

Mathematica, score 60-100-100 = -140

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

Fonction pure. Prend net {l, w}(largeur et hauteur) en entrée et donne un graphique animé en sortie. Il crée d'abord une courbe de Peano d'ordre n avec PeanoCurve. Étant donné que le cas l = w doit encore créer une courbe de Peano, nous inversons l'expression au niveau 3, similaire à la réponse de DavidC ; pour l ≠ w , nous avons juste Scalela courbe du rectangle. Cette courbe sera toujours remplie d'espace, satisfaisant le deuxième bonus. Pour le premier bonus, nous l'avons juste Animatesur toutes les tailles. Notez que OP a suggéré que cela était suffisamment différent de celui de DavidC pour justifier sa propre réponse. Le résultat pour n = 3, l = w = 1 est comme suit:

GFA Basic 3,51 (Atari ST), 156 134 124 octets

Une liste éditée manuellement au format .LST. Toutes les lignes se terminent par CR, y compris la dernière.

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

Développé et commenté

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

Exemple de sortie

Perl 6 , 117 octets

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

Essayez-le en ligne!

0 indexé. Renvoie un tableau 2D de caractères Unicode. L'idée de base est que pour les lignes inférieures, l'expression

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

donne le motif

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

Pour les lignes supérieures, l'expression est

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

Explication

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

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

Essayez-le en ligne!

renvoie une matrice booléenne

|'yest une syntaxe spécifique à ngn / k. d'autres dialectes nécessitent un :pour rendre un verbe à deux caractères monadique:|:'y

Wolfram Language 83 36 octets, (éventuellement -48 octets avec bonus)

À partir de la version 11.1, PeanoCurveest intégré.

Ma soumission originale et maladroite a gaspillé de nombreux octets sur GeometricTransformationetReflectionTransform.

Cette version très réduite a été suggérée par les alephalpha . Reverseétait nécessaire pour orienter correctement la sortie.

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

Exemple 36 octets

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

Prime

Si cela donne droit au bonus de 100 pt, il pèse 52 - 100 = -48 Le code [5]n'a pas été compté, seule la fonction pure.

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

BBC BASIC, 142 caractères ASCII (130 octets tokenisés)

Téléchargez l'interprète sur 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 octets

La sortie est mise en miroir horizontalement.

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

Essayez-le en ligne! (imprime le 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 octets

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 de @ Arnauld's Atari BASIC answer. Pour utiliser, faites quelque chose comme ceci :

reset
f 3

Stax , 19 octets

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

Exécuter et déboguer

Sortie pour 3:

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