El Triángulo de Sierpinsky es un fractal creado tomando un triángulo, disminuyendo la altura y el ancho en 1/2, creando 3 copias del triángulo resultante, y colocándolos de tal manera que cada triángulo toque a los otros dos en una esquina. Este proceso se repite una y otra vez con los triángulos resultantes para producir el triángulo de Sierpinski, como se ilustra a continuación.

Escribe un programa para generar un triángulo de Sierpinski. Puede usar cualquier método que desee para generar el patrón, ya sea dibujando los triángulos reales o usando un algoritmo aleatorio para generar la imagen. Puede dibujar en píxeles, arte ascii o lo que quiera, siempre que el resultado sea similar a la última imagen que se muestra arriba. Pocos personajes ganan.

HTML + JavaScript, 150 caracteres (ver notas de 126 caracteres)

Espacio en blanco insertado para facilitar la lectura y no contado.

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

El núcleo de esto es aplicar la regla de colorear píxeles para los cuales x & y == 0por el condicional x&y||, que produce un "triángulo rectángulo de Sierpinski"; y x-~y/2,k-yson una transformación de coordenadas para producir la visualización aproximadamente equilátera.

Una versión menos correcta (HTML-wise) tiene 126 caracteres:

<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 forma en que esto es menos correcto es que omite el titleelemento y la etiqueta final del canvaselemento, los cuales son necesarios para un documento correcto aunque omitirlos no cambie la interpretación del documento).

Se pueden guardar tres caracteres eliminando ka favor de la constante 64, a costa de un resultado menor; No contaría la 8opción ya que no tiene suficientes detalles.

Tenga en cuenta que un tamaño de 256 o superior requiere atributos en el <canvas>para aumentar el tamaño del lienzo del valor predeterminado.

GolfScript ( 43 42 caracteres)

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

Salida:

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

Cambia el "3" a un número mayor para un triángulo más grande.

Pitón (234)

Máximo golf, pequeña imagen:

#!/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')

Requiere python3-cairo.

Para obtener una imagen grande y bonita necesitaba 239 caracteres.

Mathematica - 32 caracteres

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

Mathematica - 37 caracteres

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

Esto producirá una tabla 2D de 0 y 1, donde los 1s están dibujando el Triángulo de Sierpinski.

Python, 101 86

Utiliza la regla 90 autómata.

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

Esto es más largo, pero más bonito.

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

Editar: jugar con cuerdas directamente, deshacerse de los cortes odiosamente largos, hacer que la salida sea más bonita.

Salida:

                               Δ                               
                              Δ Δ                              
                             Δ   Δ                             
                            Δ Δ Δ Δ                            
                           Δ       Δ                           
                          Δ Δ     Δ Δ                          
                         Δ   Δ   Δ   Δ                         
                        Δ Δ Δ Δ Δ Δ Δ Δ                        
                       Δ               Δ                       
                      Δ Δ             Δ Δ                      
                     Δ   Δ           Δ   Δ                     
                    Δ Δ Δ Δ         Δ Δ Δ Δ                    
                   Δ       Δ       Δ       Δ                   
                  Δ Δ     Δ Δ     Δ Δ     Δ Δ                  
                 Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ                 
                Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ                
               Δ                               Δ               
              Δ Δ                             Δ Δ              
             Δ   Δ                           Δ   Δ             
            Δ Δ Δ Δ                         Δ Δ Δ Δ            
           Δ       Δ                       Δ       Δ           
          Δ Δ     Δ Δ                     Δ Δ     Δ Δ          
         Δ   Δ   Δ   Δ                   Δ   Δ   Δ   Δ         
        Δ Δ Δ Δ Δ Δ Δ Δ                 Δ Δ Δ Δ Δ Δ Δ Δ        
       Δ               Δ               Δ               Δ       
      Δ Δ             Δ Δ             Δ Δ             Δ Δ      
     Δ   Δ           Δ   Δ           Δ   Δ           Δ   Δ     
    Δ Δ Δ Δ         Δ Δ Δ Δ         Δ Δ Δ Δ         Δ Δ Δ Δ    
   Δ       Δ       Δ       Δ       Δ       Δ       Δ       Δ   
  Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ  
 Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ 
Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ

J

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

No es ideal, ya que el triángulo es asimétrico y seguido de mucho espacio en blanco, pero, no obstante, me pareció interesante.

Salida:

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

Una explicación rápida:

El verbo (,~,.~)es lo que está haciendo el trabajo aquí. Es un gancho que primero cose ,.el argumento para sí mismo ( o-> oo) y luego agrega el argumento original a la salida:

oo

se convierte

oo
o

Este verbo se repite 6 veces ^:6con la salida de cada iteración convirtiéndose en la entrada de la siguiente iteración. Asi que

oo
o

se convierte

oooo
o o
oo
o

que a su vez se convierte

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

Luego, he usado el adverbio oblicuo en append ,/.para leer las filas en diagonal para enderezar (ish) el triángulo. No necesitaba hacer esto, como señala randomra . Podría haber invertido |.el lote para obtener el mismo resultado. Aún mejor, podría haber usado (,,.~)^:6,'o'para guardar el paso inverso por completo.

Ah bueno, vives y aprendes. :-)

APL (51)

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

Explicación:

• A←67⍴0: A es un vector de 67 ceros
• A[34]←1: el elemento 34 es 1
• {...}A: comenzando con A, hacer:
• ~⊃⍵:: si el primer elemento de la fila actual es cero
• ⍵,∇: agrega la fila actual a la respuesta, y recurse con:
• (1⌽⍵)≠¯1⌽⍵: el vector donde cada elemento es el XOR de sus vecinos en la generación anterior
• ⋄⍬: de lo contrario, hemos terminado
• 32 67⍴: formatee esto en una matriz 67x32
• 1+: agregue uno para seleccionar el valor correcto de la matriz de caracteres
• ' ○'[... ]: genera un espacio (no es parte del triángulo) o un círculo (cuando es parte del triángulo)

Salida:

                                 ○                                 
                                ○ ○                                
                               ○ ○                               
                              ○ ○ ○ ○                              
                             ○ ○                             
                            ○ ○ ○ ○                            
                           ○ ○ ○ ○                           
                          ○ ○ ○ ○ ○ ○ ○ ○                          
                         ○ ○                         
                        ○ ○ ○ ○                        
                       ○ ○ ○ ○                       
                      ○ ○ ○ ○ ○ ○ ○ ○                      
                     ○ ○ ○ ○                     
                    ○ ○ ○ ○ ○ ○ ○ ○                    
                   ○ ○ ○ ○ ○ ○ ○ ○                   
                  ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○                  
                 ○ ○                 
                ○ ○ ○ ○                
               ○ ○ ○ ○               
              ○ ○ ○ ○ ○ ○ ○ ○              
             ○ ○ ○ ○             
            ○ ○ ○ ○ ○ ○ ○ ○            
           ○ ○ ○ ○ ○ ○ ○ ○           
          ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○          
         ○ ○ ○ ○         
        ○ ○ ○ ○ ○ ○ ○ ○        
       ○ ○ ○ ○ ○ ○ ○ ○       
      ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○      
     ○ ○ ○ ○ ○ ○ ○ ○     
    ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○    
   ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○   
  ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○  

Haskell (291)

No soy muy bueno en los códigos de golf de 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

Salida de solve 4es:

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

QBasic 151 Personajes

Como ejemplo, así es como se puede hacer en 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

Pitón (42)

Originalmente quería publicar algunas sugerencias sobre la solución de boothbys (que en realidad usa la regla 18 :), pero no tenía suficiente reputación para comentar, así que lo convertí en otra respuesta. Como cambió su enfoque, agregué alguna explicación. Mis sugerencias habrían sido:

1. use '% d' * 64% tuple (x) en lugar de '' .join (map (str, x)
2. cambiar a ceros en lugar de ajustar la lista

que habría llevado al siguiente código (93 caracteres):

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

Pero optimicé aún más, primero usando una clave larga en lugar de una matriz entera y simplemente imprimiendo la representación binaria (75 caracteres):

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

Y finalmente imprimiendo la representación octal, que ya es compatible con la interpolación printf (42 caracteres):

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

Todos ellos imprimirán:

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

Por supuesto, también hay una solución gráfica (131 caracteres):

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

:RE

8086 Código de máquina: 30 bytes.

NOTA: Este no es mi código y no debe aceptarse como respuesta . Encontré esto mientras trabajaba en un problema de CG diferente para emular una CPU 8086 . El archivo de texto incluido da crédito a David Stafford , pero eso es lo mejor que se me ocurrió.

Estoy publicando esto porque es inteligente, breve, y pensé que querrías verlo.

Utiliza códigos de operación superpuestos para empacar más instrucciones en un espacio más pequeño. Sorprendentemente inteligente. Aquí está el código de la máquina:

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 decodificador directo se ve así:

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

Cuando corres, cuando ocurre el salto en 0x0115, observa que vuelve a saltar a 0x010C, justo en el medio de una instrucción anterior:

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]

¡Brillante! Espero que no les importe que comparta esto. Sé que no es una respuesta per se, pero es interesante para el desafío.

Aquí está en acción:

C 127 119 116 108 65

Este usa el truco de la respuesta HTML de ^ i & jconseguir que imprima una salida bonita tomaría 1 char más (puede obtener una salida realmente fea sacrificando la a^).

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

Para que sea bastante gire (32^i&j)a (32|!(i&j))y convertirlo a partir ++i<ade ++i<=a. Sin embargo, el desperdicio de caracteres en miradas me parece poco gótico.

Salida fea:

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

De hecho, me gusta cómo se ve. Pero si insiste en que sea bonita, puede acoplar cuatro caracteres. Salida bonita:

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

Dejando la versión anterior de 108 caracteres, autómatas celulares.

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(""));}

Así que no creo que vaya a hacerlo mucho más corto que esto, así que explicaré el código. Dejaré esta explicación, ya que algunos de los trucos podrían ser útiles.

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
}

Alguna salida

                             # #                               
                            #   #                              
                           # # # #                             
                          #       #                            
                         # #     # #                           
                        #   #   #   #                          
                       # # # # # # # #                         
                      #               #                        
                     # #             # #                       
                    #   #           #   #                      
                   # # # #         # # # #                     
                  #       #       #       #                    
                 # #     # #     # #     # #                   
                #   #   #   #   #   #   #   #                  
               # # # # # # # # # # # # # # # #                 
              #                               #                
             # #                             # #               
            #   #                           #   #              
           # # # #                         # # # #             
          #       #                       #       #            
         # #     # #                     # #     # #           
        #   #   #   #                   #   #   #   #          
       # # # # # # # #                 # # # # # # # #         
      #               #               #               #        
     # #             # #             # #             # #       
    #   #           #   #           #   #           #   #      
   # # # #         # # # #         # # # #         # # # #     
  #       #       #       #       #       #       #       #    
 # #     # #     # #     # #     # #     # #     # #     # #   
#   #   #   #   #   #   #   #   #   #   #   #   #   #   #   #  
 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

Código 80x86 / MsDos - 10 bytes

Como sizecoder especializado en introducciones muy pequeñas en MsDos, logré crear un programa que ocupa solo 10 bytes.

en hexadecimal:

04 13 CD 10 20 E9 B4 0C E2 F6

en asm:

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

La primera versión que codifiqué fue "Colpinski", que tiene un tamaño de 16 bytes, e incluso interactiva de manera que puede cambiar el color con el teclado y el mouse. Junto con "Frag", otro codificador de tamaño, lo redujimos a 13 bytes, lo que permite un programa de 10 bytes que solo contiene la rutina central.

Se vuelve un poco más interesante cuando las cosas están animadas, por lo que mencionaré otra versión, Zoompinski 64 , tratando de imitar el comportamiento exacto de "Zoompinski C64" en 512 bytes, también para MsDos, 64 bytes de tamaño como su nombre indica.

Es posible optimizar esto más abajo hasta 31 Bytes, mientras se pierde elegancia, colores y simetría (fuente y ejecutable disponible detrás del enlace de arriba)

Descarga el original y comenta en "Pouet"

PostScript, 120 caracteres

-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

Salida de Ghostscript:

Esto es dibujar la figura triplicando recursivamente lo que ya está dibujado.

El primer paso es dibujar una línea. La línea se guarda como una ruta de usuario, luego la ruta de usuario se agrega dos veces más después de rotar 120 grados cada vez. [2 0 0 2 7 4]concatmueve el "punto de rotación" al centro del próximo gran "triángulo central" blanco que debe estar encerrado por las réplicas del triángulo que ya tenemos. Aquí, volvemos al paso 1 (crear un upath que se triplica por rotación).

El número de iteraciones está controlado por el primer número en la línea 3.

J (9 caracteres)

Fácilmente lo más feo, realmente necesitas entrecerrar los ojos para ver la salida;)

2|!/~i.32

produce la salida

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

Por supuesto, puede mostrarlo gráficamente:

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

APL, 37 32 ( 28 23)

Triángulo vertical ( 37 32-char)

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

Explicación

• 1 2⍴'/\': Crear una matriz de 1 × 2 caracteres /\
• {((-1⌷⍴⍵)⌽⍵,∊⍵)⍪⍵,⍵}: Una función que rellena el argumento correcto en ambos lados con espacios en blanco para crear una matriz doble de ancho, luego lamina el argumento derecho en sí mismo doblado en la parte inferior.
  Por ejemplo, /\se convertiría

 / \ 
/ \ / \

• ⍣⎕: Repetir los tiempos de la función (entrada del usuario).

Salida de ejemplo

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

Triángulo sesgado ( 28 23-char)

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

Explicación

• 1 1⍴'○': Crear una matriz de caracteres 1 × 1 ○
• {(⍵,∊⍵)⍪⍵,⍵}: Una función que rellena el argumento derecho a la derecha con espacios en blanco para crear una matriz doble de ancho, luego lamina el argumento derecho en sí mismo doblado en la parte inferior.
  Por ejemplo, ○se convertiría

○ 
○○

• ⍣⎕: Repetir los tiempos de la función (entrada del usuario).

Salida de ejemplo

○               
○○              
○ ○             
○○○○            
○   ○           
○○  ○○          
○ ○ ○ ○         
○○○○○○○○        
○       ○       
○○      ○○      
○ ○     ○ ○     
○○○○    ○○○○    
○   ○   ○   ○   
○○  ○○  ○○  ○○  
○ ○ ○ ○ ○ ○ ○ ○ 
○○○○○○○○○○○○○○○○

Pitón (75)

Llego dos años tarde a la fiesta, pero me sorprende que nadie haya tomado este enfoque todavía

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

Utiliza el producto Kronecker para reemplazar una matriz por múltiples copias de sí mismo.

Podría guardar dos caracteres utilizando la x=kron(x,x);x=kron(x,x)línea tres para obtener una imagen de 16x16 píxeles con tres niveles visibles o agregar otro carácter al iterador y terminar con una imagen de 2 ^ 16 x 2 ^ 16 = 4.3 Gigapíxeles y 15 niveles de triángulo.

Logo, 75 caracteres

59 caracteres para la primera función, la segunda llama a la primera con el tamaño y la profundidad / número de iteraciones. Entonces, puede llamar a la primera función del intérprete con el comando: e 99 5, o el tamaño que desee generar

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

matlab 56

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

J (18 caracteres)

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

Resultado

*                               
**                              
* *                             
****                            
*   *                           
**  **                          
* * * *                         
********                        
*       *                       
**      **                      
* *     * *                     
****    ****                    
*   *   *   *                   
**  **  **  **                  
* * * * * * * *                 
****************                
*               *               
**              **              
* *             * *             
****            ****            
*   *           *   *           
**  **          **  **          
* * * *         * * * *         
********        ********        
*       *       *       *       
**      **      **      **      
* *     * *     * *     * *     
****    ****    ****    ****    
*   *   *   *   *   *   *   *   
**  **  **  **  **  **  **  **  
* * * * * * * * * * * * * * * * 
********************************

Python (90 caracteres)

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)

Pruébalo en línea

Dibuja una línea fractal que llena el Triángulo de Sierpinsky

Mathematica 67

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

Mathematica 92

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

Mathematica , 29 bytes

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

El tetraedro de Sierpinski se puede dibujar de manera similar:

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

J , ³⁷ 35 bytes

-2 bytes gracias a FrownyFrog

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

Pruébalo en línea!

Esta es la versión de arte ascii de Peter Taylor convertida a J. Podría guardar bytes con una versión menos bonita, pero ¿por qué?

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

Lua script en Golly , 54 bytes

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

Golly es un simulador de autómatas celulares con soporte para secuencias de comandos Lua y Python.

Este script establece la regla en Wolfram Rule 60, establece la celda en (0,0) en 1 y ejecuta 512 pasos.

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

Reescribir usando cadenas y la recursión termina exactamente en el mismo recuento. Pero se superan las limitaciones de profundidad del enfoque macro.

Editar: fill es más corto que stroke.

Sangrado y comentado.

%!
[   % 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

Agregar 0 setlinewidthda una mejor impresión de cuán profundo es este.

APL (Dyalog Classic) , 12 bytes

×.≥∘⍉⍨↑,⍳⎕⍴2

Pruébalo en línea!

Asíntota, 152 bytes

Agregaré esto, principalmente porque no he visto más o menos respuestas en la asíntota en este sitio. Algunos bytes desperdiciados para un buen formato y generalidad, pero puedo vivir con eso. Cambiar A, B y C cambiará dónde están las esquinas del triángulo contenedor, pero probablemente no en la forma en que piensas. Aumente el número en la desigualdad para aumentar la profundidad.

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

o no golfista y legible

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

Entonces, asíntota es un lenguaje de gráficos vectoriales limpio con una sintaxis algo similar a C. Muy útil para diagramas algo técnicos. La salida es, por supuesto, en un formato vectorial de forma predeterminada (eps, pdf, svg), pero se puede convertir en básicamente todo lo que admite imagemagick. Salida:

Haskell , 166154 bytes

(-12 bytes gracias a Laikoni, (comprensión de zip y lista en lugar de zipWith y lambda, mejor forma de generar la primera línea))

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)

Pruébalo en línea!

Explicación:

La función i#ndibuja un triángulo de altura ASCII 2^ndespués de ipasos de iteración.

La codificación utilizada internamente codifica posiciones vacías como 1y posiciones completas como 0. Por lo tanto, la primera línea del triángulo está codificada como [1,1,1..0..1,1,1]con 2^n-1unos en ambos lados del cero. Para construir esta lista, comenzamos con la lista x=1<$[2..2^n], es decir, la lista [2..2^n]con todo lo mapeado 1. Luego, construimos la lista completa comox++0:x

El operador k!p(explicación detallada a continuación), dado un índice de línea ky su correspondiente pgenera una lista infinita de líneas que siguen p. Lo invocamos con 1y la línea de inicio descrita anteriormente para obtener el triángulo completo, y luego solo tomamos las primeras 2^nlíneas. Luego, simplemente imprimimos cada línea, reemplazando 1con espacio y 0con M(accediendo a la lista "M "en la ubicación 0o 1).

El operador k!pse define de la siguiente manera:

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]]

Primero, generamos tres versiones de p: 1:pque está pcon un 1antepuesto, en psí mismo y tail p++[1]que es todo menos el primer elemento de p, con un 1adjunto. Luego comprimimos estas tres listas, dándonos efectivamente todos los elementos pcon sus vecinos izquierdo y derecho, como (l,m,r). Usamos una lista de comprensión para luego calcular el valor correspondiente en la nueva línea:

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

Para entender esta expresión, debemos darnos cuenta de que hay dos casos básicos a considerar: o simplemente expandimos la línea anterior o estamos en un punto donde comienza un punto vacío en el triángulo. En el primer caso, tenemos un lugar lleno si alguno de los lugares en el vecindario está lleno. Esto se puede calcular como m*l*r; si alguno de estos tres es cero, entonces el nuevo valor es cero. El otro caso es un poco más complicado. Aquí, básicamente, necesitamos detección de bordes. La siguiente tabla muestra los ocho vecindarios posibles con el valor resultante en la nueva línea:

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

Una fórmula sencilla para obtener esta tabla sería la 1-m*r*(1-l)-m*l*(1-r)que se simplifica m*(2*l*r-l-r)+1. Ahora tenemos que elegir entre estos dos casos, que es donde usamos el número de línea k. Si mod k (2^(n-i)) == 0, tenemos que usar el segundo caso, de lo contrario, usamos el primer caso. Por lo 0^(mod k(2^n-i))tanto, el término es 0si tenemos que usar el primer caso y 1si tenemos que usar el segundo caso. Como resultado, podemos usar

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

en total: si usamos el primer caso, simplemente obtenemos m*l*r, mientras que en el segundo caso, se agrega un término adicional, dando el total general de m*(2*l*r-l-r)+1.

C, 106 caracteres

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?"/__\\":"/\\");}

(Todavía me divierte que esa puts("")es la forma más corta de generar una nueva línea en C.)

Tenga en cuenta que puede crear juntas más grandes (o más pequeñas) reemplazando la prueba 32en el forbucle con una potencia más grande (más pequeña) de dos, siempre y cuando también reemplace la 33en el medio printf()con la potencia de dos más uno.