Dessine un triangle de Sierpinski

43

Le triangle de Sierpinsky est une fractale créée en prenant un triangle, en diminuant la hauteur et la largeur de 1/2, créant ainsi 3 copies du triangle obtenu et en les plaçant de telle sorte que chaque triangle touche les deux autres sur un coin. Ce processus est répété maintes et maintes fois avec les triangles obtenus pour produire le triangle de Sierpinski, comme illustré ci-dessous.

entrez la description de l'image ici

Ecrivez un programme pour générer un triangle de Sierpinski. Vous pouvez utiliser n'importe quelle méthode pour générer le motif, en dessinant les triangles réels ou en utilisant un algorithme aléatoire pour générer l'image. Vous pouvez dessiner en pixels, en art ascii ou à votre guise, à condition que le résultat soit similaire à la dernière image ci-dessus. Le moins de personnages gagne.

code-golf math kolmogorov-complexity fractal Kibbee
la source
1
Voir aussi l'ancienne version de Stack Overflow: stackoverflow.com/questions/1726698/…
dmckee
3
J'en ai eu l'idée après avoir vu la question du triangle de Pascal et me suis rappelé l'exemple de programme présenté dans mon manuel TI-86. J'ai décidé de le convertir en QBasic, puis de le coder en golf.
Kibbee
Il n’ya pas de problème à lancer un défi qui a déjà été exécuté sur Stack Overflow, mais beaucoup de gens ne voudront plus présenter le même matériel. Donc, je les relie pour l'édification des visiteurs ultérieurs.
dmckee
Pour éviter les doublons, vous devriez peut-être modifier les règles pour autoriser uniquement les implémentations graphiques.
Primo
Beaucoup d'idées de wolfram: wolframscience.com/nksonline/page-931
luser droog

Réponses:

41

HTML + JavaScript, 150 caractères (voir notes pour 126 caractères)

Espace blanc inséré pour la lisibilité et non compté.

<title></title><canvas></canvas><script>
for(x=k=128;x--;)for(y=k;y--;)
  x&y||document.body.firstChild.getContext("2d").fillRect(x-~y/2,k-y,1,1)
</script>

L’essentiel est d’appliquer la règle de coloration des pixels pour laquelle x & y == 0le conditionnel x&y||produit un «triangle rectangle de Sierpinski»; et x-~y/2,k-ysont une transformation de coordonnées pour produire l'affichage approximativement équilatéral.

entrez la description de l'image ici

Une version moins correcte (en HTML) contient 126 caractères:

<canvas><script>
for(x=k=128;x--;)for(y=k;y--;)
  x&y||document.body.firstChild.getContext("2d").fillRect(x-~y/2,k-y,1,1)
</script>

(La façon dont ceci est moins correct est qu’il omet l’ titleélément et la balise de fin de l’ canvasélément, qui sont tous deux nécessaires pour un document correct, même si leur omission ne modifie pas l’ interprétation du document.)

Trois personnages peuvent être sauvegardés en éliminant ken faveur de la constante 64, au prix d'un résultat plus petit; Je ne compterais pas l' 8option car elle n'a pas suffisamment de détails.

Notez qu'une taille égale ou supérieure à 256 requiert des attributs <canvas>pour augmenter la taille de la zone de travail par défaut.

Kevin Reid
la source
22
Personne ne se soucie de la validation de votre code HTML par codegolf :-) Quelques améliorations: <canvas id=c>et ensuite c.getContext. Raccourcir les boucles:for(x=k=128;x--;)for(y=k;y--;)
copie le
4
Les identifiants convertis en variables globales sont un horrible défaut que je refuse de reconnaître, et WebKit ne l'implémente pas en mode standard. Merci pour le tour de boucle.
Kevin Reid
1
Amélioration mineure: x&y?0:peut être remplacée par la x&y||solution sinon agréable.
dimanche
5
Bravo, c'est juste magnifique.
Boothby
2
Comme cela contient un script, je vous recommande de le titrer comme HTML + Javascript . Cela fera comprendre plus clairement à quel type de réponse il s’agit.
30

GolfScript ( 43 42 caractères)

' /\ /__\ '4/){.+\.{[2$.]*}%\{.+}%+\}3*;n*

Sortie:

               /\               
              /__\              
             /\  /\             
            /__\/__\            
           /\      /\           
          /__\    /__\          
         /\  /\  /\  /\         
        /__\/__\/__\/__\        
       /\              /\       
      /__\            /__\      
     /\  /\          /\  /\     
    /__\/__\        /__\/__\    
   /\      /\      /\      /\   
  /__\    /__\    /__\    /__\  
 /\  /\  /\  /\  /\  /\  /\  /\ 
/__\/__\/__\/__\/__\/__\/__\/__\

Changez le "3" en un nombre plus grand pour un triangle plus grand.

Peter Taylor
la source
27

Python (234)

Golf maximale, petite image:

#!/usr/bin/env python3
from cairo import*
s=SVGSurface('_',97,84)
g=Context(s)
g.scale(97,84)
def f(w,x,y):
 v=w/2
 if w>.1:f(v,x,y);f(v,x+w/4,y-v);f(v,x+v,y)
 else:g.move_to(x,y);g.line_to(x+v,y-w);g.line_to(x+w,y);g.fill()
f(1,0,1)
s.write_to_png('s.png')

Nécessite python3-cairo.

Pour obtenir une belle image de grande taille, il me fallait 239 caractères.

Triangle de Sierpinski

Oleh Prypin
la source
1
import cairo as cvous sauver quelques caractères
quasimodo
1
cette réponse nécessite plus de votes positifs
ixtmixilix
26

Mathematica - 32 caractères 

Nest[Subsuperscript[#,#,#]&,0,5]

entrez la description de l'image ici

Mathematica - 37 caractères 

Grid@CellularAutomaton[90,{{1},0},31]

Cela produira un tableau 2D de 0 et 1, où 1 dessine le triangle de Sierpinski.

entrez la description de l'image ici

Vitaliy Kaurov
la source
2
Au prix de 5 caractères supplémentaires, votre deuxième solution s’affichera mieux avec ArrayPlot@CellularAutomaton[90, {{1}, 0}, 31]ou MatrixPlot@CellularAutomaton[90, {{1}, 0}, 31].
DavidC
1
... ou avec ReliefPlot@...
DavidC
Je comprends ça . Comment avez-vous obtenu la sortie sans tous les crochets?
Mr.Wizard
@ Mr.Wizard hmm ... D'où viennent les brackets dans le monde? Cela fonctionne même ici: mathics.net Essayez de me le faire savoir.
Vitaliy Kaurov
1
@ Vitaly Kaurov La solution principale (32 caractères) est étonnante. Pouvez-vous relever le défi "Arbre fractal" (ailleurs sur le responsable) en utilisant la même technique?
Michael Stern
22

Python, 101 86

Utilise la règle 90 automate.

x=' '*31
x+='.'+x
exec"print x;x=''.join(' .'[x[i-1]!=x[i-62]]for i in range(63));"*32

C'est plus long, mais plus joli.

x=' '*31
x+=u'Δ'+x
exec u"print x;x=''.join(u' Δ'[x[i-1]!=x[i-62]]for i in range(63));"*32

Edit: jouer directement avec les cordes, se débarrasser des tranchants excessivement longs, rendre la sortie plus jolie.

Sortie:

                               Δ                               
                              Δ Δ                              
                             Δ   Δ                             
                            Δ Δ Δ Δ                            
                           Δ       Δ                           
                          Δ Δ     Δ Δ                          
                         Δ   Δ   Δ   Δ                         
                        Δ Δ Δ Δ Δ Δ Δ Δ                        
                       Δ               Δ                       
                      Δ Δ             Δ Δ                      
                     Δ   Δ           Δ   Δ                     
                    Δ Δ Δ Δ         Δ Δ Δ Δ                    
                   Δ       Δ       Δ       Δ                   
                  Δ Δ     Δ Δ     Δ Δ     Δ Δ                  
                 Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ                 
                Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ                
               Δ                               Δ               
              Δ Δ                             Δ Δ              
             Δ   Δ                           Δ   Δ             
            Δ Δ Δ Δ                         Δ Δ Δ Δ            
           Δ       Δ                       Δ       Δ           
          Δ Δ     Δ Δ                     Δ Δ     Δ Δ          
         Δ   Δ   Δ   Δ                   Δ   Δ   Δ   Δ         
        Δ Δ Δ Δ Δ Δ Δ Δ                 Δ Δ Δ Δ Δ Δ Δ Δ        
       Δ               Δ               Δ               Δ       
      Δ Δ             Δ Δ             Δ Δ             Δ Δ      
     Δ   Δ           Δ   Δ           Δ   Δ           Δ   Δ     
    Δ Δ Δ Δ         Δ Δ Δ Δ         Δ Δ Δ Δ         Δ Δ Δ Δ    
   Δ       Δ       Δ       Δ       Δ       Δ       Δ       Δ   
  Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ  
 Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ 
Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ
boothby
la source
Ça a l'air vraiment cool: D
beary605
Utiliser cette capitale U + 0394, Delta, est une très bonne idée.
David Conrad
16

J

,/.(,~,.~)^:6,'o'

Pas idéal, car le triangle est déséquilibré et suivi par beaucoup d’espaces blancs - mais intéressant néanmoins, j’ai pensé.

Sortie:

o                                                               
oo                                                              
o o                                                             
oooo                                                            
o   o                                                           
oo  oo                                                          
o o o o                                                         
oooooooo                                                        
o       o                                                       
oo      oo                                                      
o o     o o                                                     
oooo    oooo                                                    
o   o   o   o                                                   
oo  oo  oo  oo                                                  
o o o o o o o o                                                 
oooooooooooooooo                                                
o               o                                               
oo              oo                                              
o o             o o                                             
oooo            oooo                                            
o   o           o   o                                           
oo  oo          oo  oo                                          
o o o o         o o o o                                         
oooooooo        oooooooo                                        
o       o       o       o                                       
oo      oo      oo      oo                                      
o o     o o     o o     o o                                     
oooo    oooo    oooo    oooo                                    
o   o   o   o   o   o   o   o                                   
oo  oo  oo  oo  oo  oo  oo  oo                                  
o o o o o o o o o o o o o o o o                                 
oooooooooooooooooooooooooooooooo                                
o                               o                               
oo                              oo                              
o o                             o o                             
oooo                            oooo                            
o   o                           o   o                           
oo  oo                          oo  oo                          
o o o o                         o o o o                         
oooooooo                        oooooooo                        
o       o                       o       o                       
oo      oo                      oo      oo                      
o o     o o                     o o     o o                     
oooo    oooo                    oooo    oooo                    
o   o   o   o                   o   o   o   o                   
oo  oo  oo  oo                  oo  oo  oo  oo                  
o o o o o o o o                 o o o o o o o o                 
oooooooooooooooo                oooooooooooooooo                
o               o               o               o               
oo              oo              oo              oo              
o o             o o             o o             o o             
oooo            oooo            oooo            oooo            
o   o           o   o           o   o           o   o           
oo  oo          oo  oo          oo  oo          oo  oo          
o o o o         o o o o         o o o o         o o o o         
oooooooo        oooooooo        oooooooo        oooooooo        
o       o       o       o       o       o       o       o       
oo      oo      oo      oo      oo      oo      oo      oo      
o o     o o     o o     o o     o o     o o     o o     o o     
oooo    oooo    oooo    oooo    oooo    oooo    oooo    oooo    
o   o   o   o   o   o   o   o   o   o   o   o   o   o   o   o   
oo  oo  oo  oo  oo  oo  oo  oo  oo  oo  oo  oo  oo  oo  oo  oo  
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o 
oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo

Une explication rapide:

Le verbe (,~,.~)est ce qui fait le travail ici. C'est un crochet qui coud ,.l'argument lui-même ( o-> oo), puis ajoute l'argument d'origine à la sortie:

oo

devient

oo
o

Ce verbe est répété 6 fois, ^:6la sortie de chaque itération devenant l’entrée de la prochaine itération. Alors

oo
o

devient

oooo
o o
oo
o

qui devient à son tour

oooooooo
o o o o 
oo  oo
o   o
oooo
o o
oo
o

etc. J'ai ensuite utilisé l'adverbe oblique sur append ,/.pour lire les lignes en diagonale afin de redresser (ish) le triangle. Je n'avais pas besoin de faire cela, comme le souligne randomra . J'aurais pu inverser |.le lot pour obtenir le même résultat. Mieux encore, j'aurais peut-être utilisé (,,.~)^:6,'o'pour sauvegarder complètement le pas inverse.

Eh bien, vous vivez et apprenez. :-)

Gareth
la source
1
Pourriez-vous expliquer brièvement comment cela fonctionne? Je ne connais pas J
Aditsu
1
|.(,~,.~)^:6,'o'est plus court et sans espaces supplémentaires. Et (,~,.~)^:6,1donne également une entrée décente en seulement 12 caractères!
randomra
@aditsu J'ai ajouté une explication.
Gareth
Donc, si je l'obtiens, cet opérateur concatène deux tableaux 2D?
MaiaVictor
13

APL (51)

      A←67⍴0⋄A[34]←1⋄' ○'[1+32 67⍴{~⊃⍵:⍵,∇(1⌽⍵)≠¯1⌽⍵⋄⍬}A]

Explication:

  • A←67⍴0: A est un vecteur de 67 zéros
  • A[34]←1: le 34ème élément est 1
  • {...}A: en commençant par A, faites:
  • ~⊃⍵:: si le premier élément de la ligne en cours est zéro
  • ⍵,∇: ajoute la ligne en cours à la réponse et recurse avec:
  • (1⌽⍵)≠¯1⌽⍵: le vecteur où chaque élément est le XOR de ses voisins de la génération précédente
  • ⋄⍬: sinon, nous avons terminé
  • 32 67⍴: formatez ceci dans une matrice 67x32
  • 1+: ajouter un pour sélectionner la bonne valeur dans le tableau de caractères
  • ' ○'[... ]: affiche soit un espace (ne fait pas partie du triangle), soit un cercle (quand il fait partie du triangle)

Sortie:

                                 ○                                 
                                ○ ○                                
                               ○ ○                               
                              ○ ○ ○ ○                              
                             ○ ○                             
                            ○ ○ ○ ○                            
                           ○ ○ ○ ○                           
                          ○ ○ ○ ○ ○ ○ ○ ○                          
                         ○ ○                         
                        ○ ○ ○ ○                        
                       ○ ○ ○ ○                       
                      ○ ○ ○ ○ ○ ○ ○ ○                      
                     ○ ○ ○ ○                     
                    ○ ○ ○ ○ ○ ○ ○ ○                    
                   ○ ○ ○ ○ ○ ○ ○ ○                   
                  ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○                  
                 ○ ○                 
                ○ ○ ○ ○                
               ○ ○ ○ ○               
              ○ ○ ○ ○ ○ ○ ○ ○              
             ○ ○ ○ ○             
            ○ ○ ○ ○ ○ ○ ○ ○            
           ○ ○ ○ ○ ○ ○ ○ ○           
          ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○          
         ○ ○ ○ ○         
        ○ ○ ○ ○ ○ ○ ○ ○        
       ○ ○ ○ ○ ○ ○ ○ ○       
      ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○      
     ○ ○ ○ ○ ○ ○ ○ ○     
    ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○    
   ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○   
  ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○
marinus
la source
1
Beurk. Je m'attendais à ce que ce soit 4 caractères, en utilisant des binômes mod 2 ... (ok ... peut-être un peu plus long que ça)
boothby
13

Haskell (291)

Je ne suis pas très bon au golf avec les codes haskell.

solve n = tri (putStrLn "") [2^n] n
tri m xs 1 =
  do putStrLn (l1 1 xs "/\\" 0)
     putStrLn (l1 1 xs "/__\\" 1)
     m
tri m xs n=tri m' xs (n-1)
  where m'=tri m (concat[[x-o,x+o]|x<-xs]) (n-1)
        o=2^(n-1)
l1 o [] s t=""
l1 o (x:xs) s t=replicate (x-o-t) ' '++s++l1 (x+2+t) xs s t

La sortie de solve 4est:

               /\
              /__\
             /\  /\
            /__\/__\
           /\      /\
          /__\    /__\
         /\  /\  /\  /\
        /__\/__\/__\/__\
       /\              /\
      /__\            /__\
     /\  /\          /\  /\
    /__\/__\        /__\/__\
   /\      /\      /\      /\
  /__\    /__\    /__\    /__\
 /\  /\  /\  /\  /\  /\  /\  /\
/__\/__\/__\/__\/__\/__\/__\/__\
Saeedn
la source
13

QBasic 151 caractères

Par exemple, voici comment cela peut être fait dans QBasic. 

SCREEN 9
H=.5
P=300
FOR I=1 TO 9^6
    N=RND
    IF N > 2/3 THEN
        X=H+X*H:Y=Y*H
    ELSEIF N > 1/3 THEN
        X=H^2+X*H:Y=H+Y*H    
    ELSE
        X=X*H:Y=Y*H
    END IF
    PSET(P-X*P,P-Y*P)
NEXT

entrez la description de l'image ici

Kibbee
la source
Pourriez-vous décrire la mesure dans laquelle ce programme comporte 129 caractères? J'obtiens 151 si je supprime tous les espaces probablement inutiles. (Je ne connais pas QBasic.)
Kevin Reid
J'ai vidé tous les espaces pour mon compte. Je suppose que je ne pouvais compter que les espaces non essentiels. Je ne sais pas quelle est la règle "officielle" pour le code golf.
Kibbee
4
Vous devez compter le nombre réel de caractères, y compris les espaces, dans un programme qui s'exécute et produit la sortie correcte . Naturellement, vous voudrez ne pas avoir d’espace inutile.
Kevin Reid
1
Corrigé le nombre de mes personnages.
Kibbee
13

Python (42)

Au départ, je voulais poster quelques suggestions sur la solution de boothbys (qui utilise en fait la règle 18 :), mais je n’avais pas assez de réputation pour commenter, j’en ai donc fait une autre réponse. Depuis qu'il a changé son approche, j'ai ajouté une explication. Mes suggestions auraient été:

  1. utilisez '% d' * 64% tuple (x) au lieu de '' .join (map (str, x)
  2. décaler en zéros au lieu d'enrouler la liste

qui aurait conduit au code suivant (93 caractères):

x=[0]*63
x[31]=1
exec"print'%d'*63%tuple(x);x=[a^b for a,b in zip(x[1:]+[0],[0]+x[:-1])];"*32

Mais j’optimisais encore, d’abord en utilisant un entier long au lieu d’un tableau entier et en imprimant simplement la représentation binaire (75 caractères):

x=2**31
exec"print'%d'*63%tuple(1&x>>i for i in range(63));x=x<<1^x>>1;"*32

Et enfin en imprimant la représentation octale, qui est déjà supportée par l’interpolation printf (42 caractères):

x=8**31
exec"print'%063o'%x;x=x*8^x/8;"*32

Tous vont imprimer:

000000000000000000000000000000010000000000000000000000000000000
000000000000000000000000000000101000000000000000000000000000000
000000000000000000000000000001000100000000000000000000000000000
000000000000000000000000000010101010000000000000000000000000000
000000000000000000000000000100000001000000000000000000000000000
000000000000000000000000001010000010100000000000000000000000000
000000000000000000000000010001000100010000000000000000000000000
000000000000000000000000101010101010101000000000000000000000000
000000000000000000000001000000000000000100000000000000000000000
000000000000000000000010100000000000001010000000000000000000000
000000000000000000000100010000000000010001000000000000000000000
000000000000000000001010101000000000101010100000000000000000000
000000000000000000010000000100000001000000010000000000000000000
000000000000000000101000001010000010100000101000000000000000000
000000000000000001000100010001000100010001000100000000000000000
000000000000000010101010101010101010101010101010000000000000000
000000000000000100000000000000000000000000000001000000000000000
000000000000001010000000000000000000000000000010100000000000000
000000000000010001000000000000000000000000000100010000000000000
000000000000101010100000000000000000000000001010101000000000000
000000000001000000010000000000000000000000010000000100000000000
000000000010100000101000000000000000000000101000001010000000000
000000000100010001000100000000000000000001000100010001000000000
000000001010101010101010000000000000000010101010101010100000000
000000010000000000000001000000000000000100000000000000010000000
000000101000000000000010100000000000001010000000000000101000000
000001000100000000000100010000000000010001000000000001000100000
000010101010000000001010101000000000101010100000000010101010000
000100000001000000010000000100000001000000010000000100000001000
001010000010100000101000001010000010100000101000001010000010100
010001000100010001000100010001000100010001000100010001000100010
101010101010101010101010101010101010101010101010101010101010101

Bien sûr, il existe aussi une solution graphique (131 caractères):

from PIL.Image import*
from struct import*
a=''
x=2**31
exec"a+=pack('>Q',x);x=x*2^x/2;"*32
fromstring('1',(64,32),a).save('s.png')

très petit triangle de sierpinsky :RÉ

quasimodo
la source
1
36:x=8**31;exec"print'%o'%x;x^=x/8;"*32
Aditsu
13

8086 Code machine - 30 octets.

NOTE: Ce n'est pas mon code et ne devrait pas être accepté comme une réponse . J'ai trouvé cela tout en travaillant sur un problème CG différent d'émuler un processeur 8086 . Le fichier texte inclus reconnaît David Stafford , mais c’est le meilleur que je puisse trouver.

Je poste ceci parce que c'est intelligent, bref, et je pensais que vous voudriez le voir.

Il utilise des opcodes qui se chevauchent pour regrouper plus d'instructions dans un espace plus petit. Étonnamment intelligent. Voici le code machine:

B0 13 CD 10 B3 03 BE A0 A0 8E DE B9 8B 0C 32 28 88 AC C2 FE 4E 75 F5 CD 16 87 C3 CD 10 C3

Un décodage simple ressemble à ceci:

0100: B0 13              mov AL, 13h
0102: CD 10              int 10h
0104: B3 03              mov BL, 3h
0106: BE A0 A0           mov SI, A0A0h
0109: 8E DE              mov  DS, SI
010B: B9 8B 0C           mov CX, C8Bh
010E: 32 28              xor  CH, [BX+SI]
0110: 88 AC C2 FE        mov  [SI+FEC2h], CH
0114: 4E                 dec SI
0115: 75 F5              jne/jnz -11

Lorsqu'il est exécuté, lorsque le saut à 0x0115 se produit, notez qu'il revient à 0x010C, au beau milieu d'une instruction précédente:

0100: B0 13              mov AL, 13h
0102: CD 10              int 10h
0104: B3 03              mov BL, 3h
0106: BE A0 A0           mov SI, A0A0h
0109: 8E DE              mov  DS, SI
010B: B9 8B 0C           mov CX, C8Bh
010E: 32 28              xor  CH, [BX+SI]
0110: 88 AC C2 FE        mov  [SI+FEC2h], CH
0114: 4E                 dec SI
0115: 75 F5              jne/jnz -11
010C: 8B 0C              mov  CX, [SI]
010E: 32 28              xor  CH, [BX+SI]
0110: 88 AC C2 FE        mov  [SI+FEC2h], CH
0114: 4E                 dec SI
0115: 75 F5              jne/jnz -11
010C: 8B 0C              mov  CX, [SI]

Brillant! J'espère que ça ne vous dérange pas que je partage ça. Je sais que ce n'est pas une réponse en soi, mais cela présente un intérêt pour le défi.

Ici c'est en action:

Fonctionnement

JoeFish
la source
11

C 127 119 116 108 65

Celui-ci utilise l’astuce de la réponse HTML pour l’ ^ i & jobtenir pour imprimer une jolie sortie nécessiterait 1 caractère supplémentaire (vous pouvez obtenir une sortie vraiment moche en sacrifiant le a^).

a=32,j;main(i){for(;++i<a;)putchar(a^i&j);++j<a&&main(puts(""));}

Pour le rendre joli tour (32^i&j)à (32|!(i&j))tour et tournez ++i<aà ++i<=a. Cependant, perdre du caractère sur des regards me semble ungolfish.

Sortie laide:

 ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
""  ""  ""  ""  ""  ""  ""  ""
"# !"# !"# !"# !"# !"# !"# !"#
  $$$$    $$$$    $$$$    $$$$
 !$%$% ! !$%$% ! !$%$% ! !$%$%
""$$&&  ""$$&&  ""$$&&  ""$$&&
"#$%&' !"#$%&' !"#$%&' !"#$%&'
      ((((((((        ((((((((
 ! ! !()()()() ! ! ! !()()()()
""  ""((**((**  ""  ""((**((**
"# !"#()*+()*+ !"# !"#()*+()*+
  $$$$((((,,,,    $$$$((((,,,,
 !$%$%()(),-,- ! !$%$%()(),-,-
""$$&&((**,,..  ""$$&&((**,,..
"#$%&'()*+,-./ !"#$%&'()*+,-./
              0000000000000000
 ! ! ! ! ! ! !0101010101010101
""  ""  ""  ""0022002200220022
"# !"# !"# !"#0123012301230123
  $$$$    $$$$0000444400004444
 !$%$% ! !$%$%0101454501014545
""$$&&  ""$$&&0022446600224466
"#$%&' !"#$%&'0123456701234567
      ((((((((0000000088888888
 ! ! !()()()()0101010189898989
""  ""((**((**0022002288::88::
"# !"#()*+()*+0123012389:;89:;
  $$$$((((,,,,000044448888<<<<
 !$%$%()(),-,-010145458989<=<=
""$$&&((**,,..0022446688::<<>>
"#$%&'()*+,-./0123456789:;<=>?

En fait, j'aime bien à quoi ça ressemble. Mais si vous insistez pour que ce soit joli, vous pouvez amarrer quatre personnages. Jolie sortie:

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
  !!  !!  !!  !!  !!  !!  !!  !
  !   !   !   !   !   !   !   !
!!    !!!!    !!!!    !!!!    !
!     ! !     ! !     ! !     !
      !!      !!      !!      !
      !       !       !       !
!!!!!!        !!!!!!!!        !
! ! !         ! ! ! !         !
  !!          !!  !!          !
  !           !   !           !
!!            !!!!            !
!             ! !             !
              !!              !
              !               !
!!!!!!!!!!!!!!                !
! ! ! ! ! ! !                 !
  !!  !!  !!                  !
  !   !   !                   !
!!    !!!!                    !
!     ! !                     !
      !!                      !
      !                       !
!!!!!!                        !
! ! !                         !
  !!                          !
  !                           !
!!                            !
!                             !
                              !
                              !

Laissant l'ancienne version de l'automate cellulaire à 108 caractères.

j,d[99][99];main(i){d[0][31]=3;for(;i<64;)d[j+1][i]=putchar(32|d[j][i+2]^d[j][i++]);++j<32&&main(puts(""));}

Donc, je ne pense pas que je vais le raccourcir beaucoup, alors je vais expliquer le code. Je vais laisser cette explication, car certaines astuces pourraient être utiles.

j,d[99][99]; // these init as 0
main(i){ //starts at 1 (argc)
  d[0][48]=3; //seed the automata (3 gives us # instead of !)
  for(;i<98;) // print a row
    d[j+1][i]=putchar(32|d[j][i+2]]^d[j][i++]);
    //relies on undefined behavoir. Works on ubuntu with gcc ix864
    //does the automata rule. 32 + (bitwise or can serve as + if you know
    //that (a|b)==(a^b)), putchar returns the char it prints
  ++j<32&&main(puts(""));
  // repeat 32 times
  // puts("") prints a newline and returns 1, which is nice
}

Quelques sorties

                             # #                               
                            #   #                              
                           # # # #                             
                          #       #                            
                         # #     # #                           
                        #   #   #   #                          
                       # # # # # # # #                         
                      #               #                        
                     # #             # #                       
                    #   #           #   #                      
                   # # # #         # # # #                     
                  #       #       #       #                    
                 # #     # #     # #     # #                   
                #   #   #   #   #   #   #   #                  
               # # # # # # # # # # # # # # # #                 
              #                               #                
             # #                             # #               
            #   #                           #   #              
           # # # #                         # # # #             
          #       #                       #       #            
         # #     # #                     # #     # #           
        #   #   #   #                   #   #   #   #          
       # # # # # # # #                 # # # # # # # #         
      #               #               #               #        
     # #             # #             # #             # #       
    #   #           #   #           #   #           #   #      
   # # # #         # # # #         # # # #         # # # #     
  #       #       #       #       #       #       #       #    
 # #     # #     # #     # #     # #     # #     # #     # #   
#   #   #   #   #   #   #   #   #   #   #   #   #   #   #   #  
 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
walpen
la source
1
Cela ne semble pas être un triangle de Sierpinski; il se scinde en trois sous-triangles (en descendant) au lieu de deux, et on voit que cela ne produit pas de grand triangle central vide.
Kevin Reid
1
C'est parce que j'ai utilisé la mauvaise règle: O. Correction, et rasé quelques caractères.
walpen
9

Code 80x86 / MsDos - 10 octets

En tant que sizecoder spécialisé dans les très petites introductions sur MsDos, j'ai réussi à créer un programme qui n'occupe que 10 octets.

en hex:

04 13 CD 10 20 E9 B4 0C E2 F6

entrez la description de l'image ici

en asm:

X: add al,0x13
int 0x10
and cl,ch
mov ah,0x0C
loop X

La première version que j'ai codée était "Colpinski", dont la taille est de 16 octets. Elle est même interactive et vous permet de changer la couleur avec le clavier et la souris. Avec "Frag" - un autre code de taille -, nous l'avons réduit à 13 octets, permettant ainsi un programme de 10 octets contenant uniquement la routine de base.

Cela devient un peu plus intéressant quand les choses s'animent, alors je mentionnerai une autre version, Zoompinski 64 - essayant d'imiter le comportement exact de "Zoompinski C64" sur 512 octets - également pour MsDos, taille de 64 octets comme son nom l'indique.

Il est possible d’optimiser cet objet jusqu’à 31 octets, tout en perdant élégance, couleurs et symétrie (source et fichier exécutable disponibles derrière le lien ci-dessus).

Téléchargez l'original et commentez "Pouet"

HellMood
la source
2
Vous devriez poster un vidage hexadécimal de votre code, afin que nous puissions voir les octets réels.
mbomb007
8

PostScript, 120 caractères

-7 -4 moveto
14 0 rlineto
7{true upath dup
2{120 rotate uappend}repeat[2 0 0 2 7 4]concat}repeat
matrix setmatrix
stroke

Sortie Ghostscript:

Rendu Ghostscript

Ceci dessine la figure en triplant récursivement ce qui est déjà dessiné.

La première étape consiste à tracer une ligne. La ligne est enregistrée en tant que chemin utilisateur, puis le chemin utilisateur est ajouté deux fois après une rotation de 120 degrés à chaque fois. [2 0 0 2 7 4]concatdéplace le "point de rotation" vers le centre du prochain grand "triangle central" blanc qui doit être entouré par des réplications du triangle que nous avons déjà. Nous revenons ici à l’étape 1 (création d’une trajectoire ascendante triplée par rotation).

Le nombre d'itérations est contrôlé par le premier nombre de la ligne 3.

Thomas W.
la source
+1 très bien. Je n'avais aucune idée que sa colère pourrait être utilisée comme ça.
luser droog
Hé, vous avez le représentant pour ajouter cette image maintenant!
Luser droog
@ luserdroog: C'est vrai (même en partie grâce à vous)!
Thomas W.
7

J (9 caractères)

Facilement le plus moche, vous devez vraiment plisser les yeux pour voir la sortie;)

2|!/~i.32

produit la sortie

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1
0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1
0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1
0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1
0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1

bien sûr, vous pouvez l'afficher graphiquement:

load 'viewmat'
viewmat 2|!/~i.32

Image

Mark Allen
la source
comment le ... quoi?
acolyte
4
Le code exploite la propriété du triangle de Pascal que si vous coloriez tous les nombres impairs (pairs) en noir (blanc), vous obtenez le triangle de Sierpinski. (voir cette image). i.32 génère la liste 0 1 2 ... 31. Ensuite!! ~ calcule les coefficients binomiaux de chaque élément de la liste, c'est-à-dire qu'il produit une matrice 32 x 32 dans laquelle est incorporé le triangle de Pascal. Puis 2 | est simplement chaque élément de cette matrice mod 2, produisant le triangle de Sierpinski.
Mark Allen
4

APL, 37 32 ( 28 23)

Triangle vertical ( 37 caractères 32 caractères)

({((-1⌷⍴⍵)⌽⍵,∊⍵)⍪⍵,⍵}⍣⎕)1 2⍴'/\'

Explication

  • 1 2⍴'/\': Créer une matrice de caractères 1 × 2 /\
  • {((-1⌷⍴⍵)⌽⍵,∊⍵)⍪⍵,⍵}: Une fonction qui compresse le bon argument des deux côtés avec des blancs pour créer une matrice double la plus large, puis lamine le bon argument lui-même doublé sur le fond.
    Par exemple /\deviendrait
 / \ 
/ \ / \
  • ⍣⎕: Répéter la fonction (entrée utilisateur) fois.

Exemple de sortie

               /\               
              /\/\              
             /\  /\             
            /\/\/\/\            
           /\      /\           
          /\/\    /\/\          
         /\  /\  /\  /\         
        /\/\/\/\/\/\/\/\        
       /\              /\       
      /\/\            /\/\      
     /\  /\          /\  /\     
    /\/\/\/\        /\/\/\/\    
   /\      /\      /\      /\   
  /\/\    /\/\    /\/\    /\/\  
 /\  /\  /\  /\  /\  /\  /\  /\ 
/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\

Triangle asymétrique ( 28 23 caractères)

({(⍵,∊⍵)⍪⍵,⍵}⍣⎕)1 1⍴'○'

Explication

  • 1 1⍴'○': Créer une matrice de caractères 1 × 1 ○
  • {(⍵,∊⍵)⍪⍵,⍵}: Une fonction qui compresse le bon argument à droite avec des blancs pour créer une matrice double la plus large, puis lamine le bon argument lui-même doublé sur le bas.
    Par exemple ○deviendrait
○ 
○○
  • ⍣⎕: Répéter la fonction (entrée utilisateur) fois.

Exemple de sortie

○               
○○              
○ ○             
○○○○            
○   ○           
○○  ○○          
○ ○ ○ ○         
○○○○○○○○        
○       ○       
○○      ○○      
○ ○     ○ ○     
○○○○    ○○○○    
○   ○   ○   ○   
○○  ○○  ○○  ○○  
○ ○ ○ ○ ○ ○ ○ ○ 
○○○○○○○○○○○○○○○○
TwiNight
la source
4

Python (75)

J'ai deux ans de retard à la fête, mais je suis surpris que personne n'ait encore adopté cette approche

from pylab import*
x=[[1,1],[1,0]]
for i in'123':x=kron(x,x)
imsave('a',x)

niveau 7

Utilise le produit Kronecker pour remplacer une matrice par plusieurs copies de celle-ci.

Je pourrais économiser deux caractères en utilisant la x=kron(x,x);x=kron(x,x)ligne trois pour obtenir une image de 16 x 16 pixels avec trois niveaux visibles ou ajouter un autre caractère à l'itérateur pour obtenir une image de 2 ^ 16 x 2 ^ 16 = 4,3 gigapixels et 15 niveaux de triangle.

DenDenDo
la source
3

Logo, 75 caractères

59 caractères pour seulement la première fonction, la seconde appelle la première avec la taille et la profondeur / le nombre d'itérations. Vous pouvez donc appeler la première fonction de l'interpréteur avec la commande: e 99 5, ou quelle que soit la taille que vous souhaitez afficher.

to e :s :l
if :l>0[repeat 3[e :s/2 :l-1 fd :s rt 120]]
end
to f
e 99 5
end
hal9000w
la source
+1 J'ai lu sur Logo. Quel interprète utilisez-vous? ... Logo pourrait être un ajustement naturel pour mon défi l-système .
luser droog
Si vous supprimez simplement le to fet endautour e 99 5, vous avez un programme complet exécutable en moins de caractères. En outre, dans UCBLogo (bien que pas d'autres versions), vous pouvez perdre les deux-points sur les variables pour enregistrer davantage de caractères.
Mark Reed
3

matlab 56

v=[1;-1;j];plot(filter(1,[1,-.5],v(randi(3,1,1e4))),'.')

entrez la description de l'image ici

chyanog
la source
3

J (18 caractères)

' *'{~(,,.~)^:9 ,1

Résultat

*                               
**                              
* *                             
****                            
*   *                           
**  **                          
* * * *                         
********                        
*       *                       
**      **                      
* *     * *                     
****    ****                    
*   *   *   *                   
**  **  **  **                  
* * * * * * * *                 
****************                
*               *               
**              **              
* *             * *             
****            ****            
*   *           *   *           
**  **          **  **          
* * * *         * * * *         
********        ********        
*       *       *       *       
**      **      **      **      
* *     * *     * *     * *     
****    ****    ****    ****    
*   *   *   *   *   *   *   *   
**  **  **  **  **  **  **  **  
* * * * * * * * * * * * * * * * 
********************************
Vivek Ramanujan
la source
3

Python (90 caractères)

from turtle import*
def l():left(60)
def r():right(60)
def f():forward(1)
def L(n):
 if n:n-=1;R(n);l();L(n);l();R(n)
 else:f()
def R(n):
 if n:n-=1;L(n);r();R(n);r();L(n)
 else:f()
l();L(8)

Essayez-le en ligne

Tracez une ligne fractale remplissant le triangle de Sierpinsky

AMK
la source
Avant de lancer, je recommande d'insérer ht();speed(0);up();goto(20-window_width()/2, 20-window_height()/2);down()après l'importation. Cela l'exécutera beaucoup plus rapidement et garantira que la sortie s'adapte à la toile.
mbomb007
3

Mathematica 67

ListPlot@NestList[(#+RandomChoice@{{0,0},{2,0},{1,2}})/2&,{0,0},8!]

entrez la description de l'image ici

Mathematica 92

Graphics@Polygon@Nest[Join@@(Mean/@#&/@#~Tuples~2~Partition~3&/@#)&,{{{0,0},{2,0},{1,1}}},3]

entrez la description de l'image ici

chyanog
la source
3

Mathematica , 29 octets

Image@Array[BitAnd,{2,2}^9,0]

Image @ Tableau [BitAnd, {2,2} ^ 9,0]

Le tétraèdre de Sierpinski peut être dessiné de la même manière:

Image3D[1-Array[BitXor,{2,2,2}^7,0]]

Image3D [1-Array [BitXor, {2,2,2} ^ 7,0]]

Alephalpha
la source
3

J , 37 35 octets

-2 octets grâce à FrownyFrog

(,.~,~' '&,.^:#)@[&0' /\',:'/__\'"_

Essayez-le en ligne!

Ceci est la version d'art ascii de Peter Taylor convertie en J. Pourrait économiser des octets avec une version moins jolie, mais pourquoi?

       /\       
      /__\      
     /\  /\     
    /__\/__\    
   /\      /\   
  /__\    /__\  
 /\  /\  /\  /\ 
/__\/__\/__\/__\
Jonas
la source
@]^:[-> @[&0et ' /\ '->' /\'
FrownyFrog
Savez-vous où l' &0astuce est documentée?
Jonah
1
Mentionné ici au bas de la page. Alors que cela enregistre un octet, vous perdez la possibilité d'avoir un nombre négatif de répétitions.
FrownyFrog le
Oh, vous devriez pouvoir échanger les opérandes ,~.
FrownyFrog
3

Lua script en Golly , 54 octets

g=golly()
g.setrule("W60")
g.setcell(0,0,1)
g.run(512)

Golly est un simulateur d'automate cellulaire prenant en charge les scripts Lua et Python.

Ce script définit la règle sur Wolfram Rule 60, définit la cellule sur (0,0) sur 1 et exécute 512 étapes.

entrez la description de l'image ici

Alephalpha
la source
2

Postscript, 205 203

[48(0-1+0+1-0)49(11)43(+)45(-)/s{dup
0 eq{exch{[48{1 0 rlineto}49 1 index
43{240 rotate}45{120 rotate}>>exch
get exec}forall}{exch{load
exch 1 sub s}forall}ifelse 1 add}>>begin
9 9 moveto(0-1-1)9 s fill

La réécriture à l'aide de chaînes et la récursivité aboutit exactement au même compte. Mais les limitations de profondeur de la macro-approche sont dépassées.

Edit: fill est plus court que stroke.

Mis en retrait et commenté.

%!
[   % begin dictionary
    48(0-1+0+1-0) % 0
    49(11)        % 1
    43(+)         % +
    45(-)         % -
    /s{ % string recursion-level
        dup 0 eq{ % level=0
            exch{  % iterate through string
                [
                    48{1 0 rlineto} % 0
                    49 1 index      % 1 
                    43{240 rotate}  % +
                    45{120 rotate}  % -
                >>exch get exec % interpret turtle command
            }forall
        }{ % level>0
            exch{  % iterate through string
                load exch  % lookup charcode
                1 sub s    % recurse with level-1
            }forall
        }ifelse
        1 add  % return recursion-level+1
    }
>>begin
9 9 moveto(0-1-1)9 s fill % execute and fill

Ajouter 0 setlinewidthdonne une meilleure impression de la profondeur de celle-ci.

réviser l'image en utilisant <code> fill </ code> (à peu près la même chose)

luser droog
la source
Celui-ci est mon préféré.
cjfaure
Il y a un moyen de le rendre plus court avec cette bibliothèque externe que j'ai écrite après coup et que je ne peux pas utiliser. : P
Luser droog
2

Asymptote, 152 octets

J'ajouterai ceci, la plupart du temps depuis que je n'ai pas vu plus ou moins de réponses en asymptote sur ce site. Quelques octets gaspillés pour un formatage agréable et une généralité, mais je peux vivre avec cela. Changer A, B et C changera l'endroit où se trouvent les coins du triangle conteneur, mais probablement pas comme vous le pensez. Augmentez le nombre d'inégalités pour augmenter la profondeur.

pair A=(0,0),B=(1,0),C=(.5,1);void f(pair p,int d){if(++d<7){p*=2;f(p+A*2,d);f(p+B*2,d);f(p+C*2,d);}else{fill(shift(p/2)*(A--B--C--cycle));}}f((0,0),0);

ou non-golf et lisible

pair A=(0,0), B=(1,0), C=(.5,1);

void f(pair p, int d) {
    if (++d<7) {
        p *= 2;
        f(p+A*2,d);
        f(p+B*2,d);
        f(p+C*2,d);
    } else {
        fill(shift(p/2)*(A--B--C--cycle));
    }
}

f((0,0),0);

Donc, asymptote est un langage graphique vectoriel soigné avec une syntaxe quelque peu similaire à celle du C. Très utile pour les diagrammes techniques. La sortie est bien sûr au format vectoriel par défaut (eps, pdf, svg) mais peut être convertie en pratiquement tout ce que supporte imagemagick. Sortie:

Triangle de Sierpinski

algmyr
la source
2

Haskell , 166 154 octets

(-12 octets grâce à Laikoni, (compréhension de zip et de liste au lieu de zipWith et lambda, meilleur moyen de générer la première ligne))

i#n|let k!p=p:(k+1)![m*l*r+(m*(l*r-l-r)+1)*0^mod k(2^(n-i))|(l,m,r)<-zip3(1:p)p$tail p++[1]];x=1<$[2..2^n]=mapM(putStrLn.map("M "!!))$take(2^n)$1!(x++0:x)

Essayez-le en ligne!

Explication:

La fonction i#ndessine un triangle ASCII de hauteur 2^naprès des iétapes d'itération.

Le codage utilisé en interne code les positions vides en tant que 1et les positions complètes en tant que 0. Par conséquent, la première ligne du triangle est codée comme [1,1,1..0..1,1,1]avec des 2^n-1uns des deux côtés du zéro. Pour construire cette liste, nous commençons par la liste x=1<$[2..2^n], c'est-à-dire la liste [2..2^n]avec tout ce qui est mappé 1. Ensuite, nous construisons la liste complète en tant quex++0:x

L'opérateur k!p(explication détaillée ci-dessous), à partir d'un index de ligne ket d'un correspondant, pgénère une liste infinie de lignes qui suivent p. Nous l'invoquons avec 1la ligne de départ décrite ci-dessus pour obtenir le triangle entier, puis prenons uniquement les premières 2^nlignes. Ensuite, nous imprimons simplement chaque ligne en remplaçant 1par espace et 0par M(en accédant à la liste "M "à l'emplacement 0ou 1).

Opérateur k!pest défini comme suit:

k!p=p:(k+1)![m*l*r+(m*(l*r-l-r)+1)*0^mod k(2^(n-i))|(l,m,r)<-zip3(1:p)p$tail p++[1]]

Premièrement, nous générons trois versions de p: 1:pqui est pavec un 1préfixe, plui-même et tail p++[1]qui est tout sauf le premier élément de p, avec un 1ajouté. Nous zippons ensuite ces trois listes, nous donnant effectivement tous les éléments de pleurs voisins gauche et droit, comme (l,m,r). Nous utilisons une liste de compréhension pour calculer ensuite la valeur correspondante dans la nouvelle ligne:

m*l*r+(m*(l*r-l-r)+1)*0^mod k(2^(n-i))

Pour comprendre cette expression, nous devons comprendre qu'il existe deux cas fondamentaux à prendre en compte: soit nous élargissons simplement la ligne précédente, soit nous nous trouvons à un point où commence un point vide dans le triangle. Dans le premier cas, nous avons un point rempli si l’un des points du voisinage est rempli. Cela peut être calculé comme suit m*l*r: si l'un de ces trois est zéro, alors la nouvelle valeur est zéro. L'autre cas est un peu plus compliqué. Ici, nous avons essentiellement besoin d'une détection de bord. Le tableau suivant donne les huit quartiers possibles avec la valeur résultante dans la nouvelle ligne:

000 001 010 011 100 101 110 111
 1   1   1   0   1   1   0   1

Une formule simple pour obtenir ce tableau serait ce 1-m*r*(1-l)-m*l*(1-r)qui simplifie m*(2*l*r-l-r)+1. Nous devons maintenant choisir entre ces deux cas, c'est-à-dire où nous utilisons le numéro de ligne k. Si mod k (2^(n-i)) == 0, nous devons utiliser le second cas, sinon, nous utilisons le premier cas. Le terme 0^(mod k(2^n-i))est donc 0si nous devons utiliser le premier cas et 1si nous devons utiliser le second cas. En conséquence, nous pouvons utiliser

m*l*r+(m*(l*r-l-r)+1)*0^mod k(2^(n-i))

au total - si nous utilisons le premier cas, nous obtenons simplement m*l*r, alors que dans le second cas, un terme supplémentaire est ajouté, donnant le grand total de m*(2*l*r-l-r)+1.

Sacchan
la source
1
154 octets: essayez-le en ligne! Belle explication au fait!
Laikoni
@ Laikoni Ooh, il y a de très belles améliorations!
Sacchan
1

C, 106 caractères

i,j;main(){for(;i<32;j>i/2?puts(""),j=!++i:0)
printf("%*s",j++?4:33-i+i%2*2,i/2&j^j?"":i%2?"/__\\":"/\\");}

(Cela m'amuse toujours de dire que puts("")c'est le moyen le plus court de générer une nouvelle ligne en C.)

Notez que vous pouvez créer des joints plus grands (ou plus petits) en remplaçant le test de 32la forboucle par une puissance plus grande (plus petite) de deux, à condition de remplacer également le joint 33au milieu printf()par la puissance de deux plus. une.

boite à pain
la source