Sierpinsky Triangleเป็นเศษส่วนที่สร้างขึ้นโดยการใช้รูปสามเหลี่ยมลดความสูงและความกว้างลง 1/2 โดยสร้างสำเนาของสามเหลี่ยมที่เกิดขึ้น 3 สำเนาและวางให้แต่ละสามเหลี่ยมสัมผัสอีกสองที่มุมหนึ่ง กระบวนการนี้ซ้ำแล้วซ้ำอีกซ้ำอีกครั้งกับสามเหลี่ยมที่เกิดขึ้นเพื่อสร้างสามเหลี่ยม Sierpinski ดังแสดงด้านล่าง

เขียนโปรแกรมเพื่อสร้างสามเหลี่ยม Sierpinski คุณสามารถใช้วิธีใดก็ได้ที่คุณต้องการสร้างรูปแบบไม่ว่าจะโดยการวาดสามเหลี่ยมจริงหรือโดยใช้อัลกอริทึมแบบสุ่มเพื่อสร้างภาพ คุณสามารถวาดเป็นพิกเซล, ASCII art หรืออะไรก็ได้ที่คุณต้องการตราบใดที่เอาต์พุตดูเหมือนกับภาพสุดท้ายที่แสดงด้านบน ตัวละครที่ชนะน้อยที่สุด

HTML + JavaScript, 150 ตัวอักษร (ดูหมายเหตุสำหรับ 126 ตัวอักษร)

แทรกช่องว่างเพื่อความสะดวกในการอ่านและไม่นับ

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

แกนกลางของมันคือการใช้กฎของพิกเซลการระบายสีซึ่งx & y == 0โดยเงื่อนไขx&y||ซึ่งผลิต "สามเหลี่ยมมุมฉากขวา Sierpinski"; และx-~y/2,k-yเป็นการแปลงพิกัดเพื่อสร้างการแสดงผลด้านเท่ากันหมดโดยประมาณ

เวอร์ชันที่ถูกต้อง (ฉลาดน้อยกว่า HTML) คือ 126 ตัวอักษร:

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

(วิธีที่สิ่งนี้ถูกต้องน้อยกว่าคือมันไม่ใส่titleองค์ประกอบและแท็กสิ้นสุดของcanvasองค์ประกอบซึ่งทั้งสองอย่างนี้จำเป็นสำหรับเอกสารที่ถูกต้องแม้ว่าการละเว้นจะไม่เปลี่ยนการตีความของเอกสาร)

สามารถบันทึกตัวละครสามตัวได้โดยการกำจัดkค่าคง64ที่ด้วยต้นทุนของผลลัพธ์ที่น้อยลง ฉันจะไม่นับ8ตัวเลือกเนื่องจากมีรายละเอียดไม่เพียงพอ

โปรดทราบว่าขนาด 256 หรือสูงกว่านั้นต้องใช้แอททริบิวใน<canvas>เพื่อเพิ่มขนาดผ้าใบจากค่าเริ่มต้น

GolfScript ( 43 42 ตัวอักษร)

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

เอาท์พุท:

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

เปลี่ยน "3" เป็นตัวเลขที่มากขึ้นสำหรับสามเหลี่ยมที่ใหญ่กว่า

Python (234)

การเล่นกอล์ฟสูงสุด, ภาพเล็ก ๆ :

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

python3-cairoต้องใช้

เพื่อให้ได้ภาพใหญ่ฉันต้องการ239ตัวอักษร

Mathematica - 32 ตัวอักษร

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

Mathematica - 37 ตัวอักษร

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

นี่จะสร้างตาราง 2D เป็น 0 และ 1 โดยที่ 1s กำลังวาด Sierpinski Triangle

Python, 101 86

ใช้กฎอัตโนมัติ 90 ข้อ

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

อันนี้ยาวกว่า แต่สวยกว่า

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

แก้ไข: เล่นกับสตริงโดยตรงกำจัดการแบ่งส่วนที่ยาวอย่างน่าสะพรึงกลัวออกเอาต์พุตให้สวยขึ้น

เอาท์พุท:

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

J

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

ไม่เหมาะเนื่องจากรูปสามเหลี่ยมมีความลาดเอียงและตามด้วยช่องว่างจำนวนมาก - แต่ฉันคิดว่าน่าสนใจ

เอาท์พุท:

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

คำอธิบายอย่างรวดเร็ว:

คำกริยา(,~,.~)คือสิ่งที่ทำงานที่นี่ มันเป็นตะขอที่เย็บ,.อาร์กิวเมนต์แรกให้กับตัวเอง ( o-> oo) แล้วผนวกอาร์กิวเมนต์ดั้งเดิมเข้ากับเอาต์พุต:

oo

กลายเป็น

oo
o

กริยานี้ทำซ้ำ 6 ครั้ง^:6โดยเอาต์พุตของการวนซ้ำแต่ละครั้งจะกลายเป็นอินพุตของการวนซ้ำครั้งถัดไป ดังนั้น

oo
o

กลายเป็น

oooo
o o
oo
o

ซึ่งจะกลายเป็น

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

ฯลฯ ฉันได้ใช้คำวิเศษณ์เฉียงในการผนวก,/.เพื่ออ่านแถวแนวทแยงมุมเพื่อยืด (ish) สามเหลี่ยม ฉันไม่จำเป็นต้องทำสิ่งนี้เนื่องจากrandomraชี้ให้เห็น ฉันสามารถย้อนกลับ|.ล็อตเพื่อให้ได้ผลลัพธ์เดียวกัน ยิ่งไปกว่านั้นฉันสามารถ(,,.~)^:6,'o'บันทึกขั้นตอนย้อนกลับได้อย่างสมบูรณ์

อืมคุณมีชีวิตอยู่และเรียนรู้ :-)

APL (51)

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

คำอธิบาย:

• A←67⍴0: A เป็นเวกเตอร์ของ 67 ศูนย์
• A[34]←1: องค์ประกอบที่ 34 คือ 1
• {...}A: เริ่มต้นด้วย A ทำ:
• ~⊃⍵:: ถ้าองค์ประกอบแรกของแถวปัจจุบันเป็นศูนย์
• ⍵,∇: เพิ่มแถวปัจจุบันในคำตอบและเติมเงินด้วย:
• (1⌽⍵)≠¯1⌽⍵: เวกเตอร์ที่แต่ละองค์ประกอบคือ XOR ของเพื่อนบ้านในรุ่นก่อนหน้า
• ⋄⍬: มิฉะนั้นเราจะทำ
• 32 67⍴: จัดรูปแบบนี้ในเมทริกซ์ 67x32
• 1+: เพิ่มหนึ่งรายการเพื่อเลือกค่าที่ถูกต้องจากอาร์เรย์อักขระ
• ' ○'[... ]: ส่งออกทั้งช่องว่าง (ไม่ใช่ส่วนหนึ่งของรูปสามเหลี่ยม) หรือวงกลม (เมื่อเป็นส่วนหนึ่งของรูปสามเหลี่ยม)

เอาท์พุท:

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

Haskell (291)

ฉันไม่ค่อยเก่งเรื่องการเล่นกอล์ฟรหัสฮาเซล

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

ผลลัพธ์ของsolve 4is:

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

QBasic 151 ตัวอักษร

ตัวอย่างเช่นนี่คือวิธีที่สามารถทำได้ใน 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

Python (42)

ฉันต้องการโพสต์ข้อเสนอแนะเล็กน้อยเกี่ยวกับวิธีแก้ไขปัญหาบูธ (ผู้ใช้กฎ 18 จริง ๆ :) แต่ฉันไม่มีชื่อเสียงพอที่จะแสดงความคิดเห็นดังนั้นฉันจึงทำให้มันเป็นคำตอบอื่น เนื่องจากเขาเปลี่ยนแนวทางของเขาฉันจึงเพิ่มคำอธิบายบางอย่าง คำแนะนำของฉันจะเป็น:

1. ใช้ '% d' * 64% tuple (x) แทน '' .join (map (str, x)
2. เปลี่ยนเป็นศูนย์แทนการปิดล้อมรายการ

ซึ่งจะนำไปสู่รหัสต่อไปนี้ (93 ตัวอักษร):

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

แต่ฉันปรับให้เหมาะสมที่สุดก่อนโดยใช้ longint แทนอาร์เรย์จำนวนเต็มและเพียงพิมพ์การเป็นตัวแทนไบนารี (75 อักขระ):

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

และสุดท้ายโดยการพิมพ์การแทนฐานแปดซึ่งได้รับการสนับสนุนโดยการแก้ไข printf (42 ตัวอักษร):

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

พวกเขาทั้งหมดจะพิมพ์:

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

แน่นอนว่ายังมีโซลูชันกราฟิก (131 ตัวอักษร):

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

: D

8086 รหัสเครื่อง - 30 ไบต์

หมายเหตุ: นี่คือไม่ได้รหัสของฉันและไม่ควรได้รับการยอมรับเป็นคำตอบ ฉันพบนี้ในขณะที่ทำงานในการแก้ปัญหาการกำกับดูแลกิจการที่แตกต่างกันที่จะเลียนแบบ 8086 CPU เครดิตไฟล์รวมอยู่ด้วยDavid Staffordแต่นั่นเป็นสิ่งที่ดีที่สุดที่ฉันจะได้รับ

ฉันโพสต์สิ่งนี้เพราะมันสั้นฉลาดและฉันคิดว่าคุณต้องการเห็นมัน

มันทำให้การใช้ opcodes ที่ทับซ้อนกันเพื่อแพ็คคำแนะนำเพิ่มเติมในพื้นที่ขนาดเล็ก ฉลาดอย่างน่าอัศจรรย์ นี่คือรหัสเครื่อง:

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

ตัวถอดรหัสแบบตรงขึ้นจะมีลักษณะดังนี้:

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

เมื่อทำงานเมื่อการกระโดดที่ 0x0115 เกิดขึ้นให้สังเกตว่ามันกระโดดกลับไปที่ 0x010C ตรงกลางของคำสั่งก่อนหน้า:

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]

ยอดเยี่ยม! หวังว่าพวกคุณจะไม่รังเกียจที่จะแบ่งปันสิ่งนี้ ฉันรู้ว่ามันไม่ใช่คำตอบสำหรับทุกคน แต่เป็นเรื่องที่น่าสนใจสำหรับความท้าทาย

นี่คือการกระทำ:

C 127 119 116 108 65 65

อันนี้ใช้เคล็ดลับของคำตอบ HTML ใน^ i & jการพิมพ์ออกมาสวย ๆ จะใช้เวลาอีก 1 ถ่าน (คุณสามารถเอาท์พุทที่น่าเกลียดจริงๆโดยเสียสละa^)

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

ที่จะทำให้มันสวยหัน(32^i&j)ไป(32|!(i&j))และเปิดได้จากการ++i<a ++i<=aอย่างไรก็ตามการทำลายรูปลักษณ์ภายนอกดูเหมือนว่าไม่ดีต่อฉัน

เอาท์พุทน่าเกลียด:

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

จริง ๆ แล้วฉันชอบลักษณะที่ปรากฏ แต่ถ้าคุณยืนยันว่ามันสวยคุณสามารถเชื่อมต่อสี่ตัวอักษรได้ เอาท์พุทสวย:

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

ออกจากรุ่นเก่า 108 char, automata ของเซลลูล่าร์

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

ดังนั้นฉันไม่คิดว่าฉันจะทำให้สั้นกว่านี้มากนักดังนั้นฉันจะอธิบายรหัส ฉันจะอธิบายนี้เพราะเทคนิคบางอย่างอาจมีประโยชน์

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
}

เอาท์พุทบางอย่าง

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

80x86 รหัส / MsDos - 10 ไบต์

ในฐานะที่เป็น sizecoder เฉพาะสำหรับ intros เล็ก ๆ น้อย ๆ บน MsDos i มีการจัดการที่จะเกิดขึ้นกับโปรแกรมที่ใช้เพียง 10 ไบต์

ใน hex:

04 13 CD 10 20 E9 B4 0C E2 F6

ใน asm:

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

รุ่นแรกที่ฉันเขียนคือ "Colpinski" ซึ่งมีขนาด 16 ไบต์และแม้แต่แบบโต้ตอบในแบบที่คุณสามารถเปลี่ยนสีได้ด้วยแป้นพิมพ์และเมาส์ เมื่อรวมกับ "Frag" - sizecoder อื่น - เราได้นำขนาดนั้นลงเหลือ 13 ไบต์ทำให้สามารถใช้โปรแกรมขนาด 10 ไบต์ซึ่งประกอบไปด้วยรูทีนหลัก

มันน่าสนใจมากขึ้นเมื่อสิ่งต่าง ๆ เคลื่อนไหวดังนั้นฉันจะพูดถึงอีกเวอร์ชันหนึ่งZoompinski 64 - พยายามเลียนแบบพฤติกรรมที่แน่นอนของ "Zoompinski C64" ใน 512 ไบต์ - สำหรับ MsDos ขนาด 64 ไบต์ตามชื่อที่แนะนำ

เป็นไปได้ที่จะเพิ่มประสิทธิภาพนี้ให้สูงขึ้นถึง 31 ไบต์ในขณะที่การสูญเสียความสง่างามสีและความสมมาตร

ดาวน์โหลดต้นฉบับและแสดงความคิดเห็นใน "Pouet"

PostScript, 120 ตัวอักษร

-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

เอาต์พุต Ghostscript:

นี่คือการวาดรูปโดยการสุ่มสามสิ่งที่วาดซ้ำแล้วซ้ำอีก

ขั้นตอนแรกคือการวาดเส้น บรรทัดถูกบันทึกเป็นผู้ใช้จากนั้นผู้ใช้จะถูกเพิ่มอีกสองครั้งหลังจากหมุน 120 องศาในแต่ละครั้ง [2 0 0 2 7 4]concatย้าย "จุดหมุน" ไปที่กึ่งกลางของ "สามเหลี่ยมกลาง" สีขาวตัวใหญ่ถัดไปซึ่งจะถูกล้อมรอบด้วยการจำลองแบบของสามเหลี่ยมที่เรามีอยู่แล้ว ที่นี่เรากลับไปที่ขั้นตอนที่ 1 (สร้างความปั่นป่วนที่เพิ่มขึ้นสามเท่าด้วยการหมุน)

จำนวนการวนซ้ำถูกควบคุมโดยหมายเลขแรกในบรรทัดที่ 3

J (9 ตัวอักษร)

ได้อย่างง่ายดายน่าเกลียดที่สุดคุณต้องเหล่เพื่อดูผลลัพธ์;)

2|!/~i.32

ผลิตผลลัพธ์

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

แน่นอนคุณสามารถแสดงกราฟิก:

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

APL, 37 32 ( 28 23)

สามเหลี่ยมตั้งตรง ( 37 32 ตัวอักษร)

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

คำอธิบาย

• 1 2⍴'/\': สร้างเมทริกซ์ 1 × 2 อักขระ /\
• {((-1⌷⍴⍵)⌽⍵,∊⍵)⍪⍵,⍵}: ฟังก์ชันที่วางอาร์กิวเมนต์ด้านขวาทั้งสองด้านด้วยช่องว่างเพื่อสร้างเมทริกซ์ที่กว้างเป็นสองเท่าจากนั้นลามิเนตอาร์กิวเมนต์ที่ถูกต้องจะเพิ่มขึ้นเป็นสองเท่าที่ด้านล่าง
  เช่น/\จะกลายเป็น

 / \ 
/ \ / \

• ⍣⎕: เรียกใช้ฟังก์ชันอีกครั้ง (อินพุตของผู้ใช้)

ตัวอย่างผลลัพธ์

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

เบ้สามเหลี่ยม ( 28 23-char)

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

ชี้แจง

• 1 1⍴'○': สร้างเมทริกซ์ 1 × 1 อักขระ ○
• {(⍵,∊⍵)⍪⍵,⍵}: ฟังก์ชันที่วางอาร์กิวเมนต์ด้านขวาทางด้านขวาด้วยช่องว่างเพื่อสร้างเมทริกซ์ที่กว้างเป็นสองเท่าจากนั้นลามิเนตอาร์กิวเมนต์ที่ถูกต้องนั้นจะเพิ่มขึ้นเป็นสองเท่าที่ด้านล่าง
  เช่น○จะกลายเป็น

○ 
○○

• ⍣⎕: เรียกใช้ฟังก์ชันอีกครั้ง (อินพุตของผู้ใช้)

ตัวอย่างผลลัพธ์

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

Python (75)

ฉันไปงานเลี้ยงมาสองปีแล้ว แต่ฉันแปลกใจที่ยังไม่มีใครใช้วิธีนี้

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

ใช้ผลิตภัณฑ์ Kroneckerเพื่อแทนที่เมทริกซ์ด้วยตัวเองหลายสำเนา

ฉันสามารถบันทึกสองตัวอักษรโดยใช้x=kron(x,x);x=kron(x,x)ในบรรทัดที่สามเพื่อรับภาพ 16x16 พิกเซลที่มีสามระดับที่มองเห็นหรือเพิ่มตัวละครอื่น ๆ เพื่อ iterator และท้ายด้วยภาพ 2 ^ 16 x 2 ^ 16 = 4.3 Gigapixel และ 15 ระดับสามเหลี่ยม

โลโก้ขนาด 75 ตัวอักษร

59 ตัวอักษรสำหรับฟังก์ชั่นแรกเพียงอันที่สองเรียกครั้งแรกด้วยขนาดและความลึก / จำนวนการวนซ้ำ ดังนั้นคุณสามารถเรียกใช้ฟังก์ชันแรกจากล่ามด้วยคำสั่ง: e 99 5 หรือขนาดใดก็ได้ที่คุณต้องการส่งออก

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 ตัวอักษร)

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

ผลลัพธ์

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

Python (90 ตัวอักษร)

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)

ลองออนไลน์

วาดเส้นเศษส่วนกรอกสามเหลี่ยม 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 ไบต์

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

จัตุรมุข Sierpinski สามารถวาดในลักษณะที่คล้ายกัน:

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

J , ³⁷ 35 ไบต์

-2 ไบต์ขอบคุณ FrownyFrog

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

ลองออนไลน์!

นี่เป็นเวอร์ชั่น ASCII ของปีเตอร์เทย์เลอร์ที่แปลงเป็น J. สามารถบันทึกไบต์ด้วยเวอร์ชันที่สวยงามน้อยกว่า แต่ทำไม?

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

Lua script ในGolly , 54 ไบต์

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

Golly เป็นโปรแกรมจำลองเซลลูลาร์อัตโนมัติพร้อมการสนับสนุนการเขียนสคริปต์ Lua และ Python

สคริปต์นี้ตั้งกฎเป็น Wolfram Rule 60 ตั้งค่าเซลล์ที่ (0,0) เป็น 1 และเรียกใช้ขั้นตอน 512

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

เขียนซ้ำโดยใช้สตริงและการเรียกซ้ำเกิดขึ้นที่จำนวนเดียวกัน แต่ข้อ จำกัด เชิงลึกของวิธีการมาโครจะเอาชนะ

แก้ไข: สั้นกว่าfillstroke

เยื้องและแสดงความคิดเห็น

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

การเพิ่ม0 setlinewidthให้ความประทับใจที่ดีขึ้นว่าชิ้นส่วนนี้ลึกเพียงใด

APL (Dyalog Classic)ขนาด 12 ไบต์

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

ลองออนไลน์!

เส้นกำกับ 152 ไบต์

ฉันจะเพิ่มส่วนใหญ่เนื่องจากฉันเห็นมากหรือน้อยไม่มีคำตอบใน asymptote บนไซต์นี้ ไบต์ที่สูญเสียไปเล็กน้อยสำหรับการจัดรูปแบบและทั่วไปที่ดี แต่ฉันสามารถอยู่กับมันได้ การเปลี่ยน A, B และ C จะเปลี่ยนที่มุมของรูปสามเหลี่ยมที่บรรจุอยู่ แต่อาจไม่ใช่ในแบบที่คุณคิด เพิ่มจำนวนในความไม่เท่าเทียมกันเพื่อเพิ่มความลึก

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

หรือ ungolfed และสามารถอ่านได้

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

ดังนั้นเส้นกำกับเป็นภาษากราฟิกแบบเวกเตอร์ที่เรียบร้อยซึ่งมีไวยากรณ์คล้าย C ค่อนข้างมีประโยชน์สำหรับไดอะแกรมทางเทคนิค แน่นอนว่าเอาต์พุตในรูปแบบเวกเตอร์โดยค่าเริ่มต้น (eps, pdf, svg) แต่สามารถแปลงเป็นทุกสิ่งที่ imagemagick รองรับ เอาท์พุท:

Haskell , 166 154 ไบต์

(-12 ไบต์ขอบคุณ Laikoni, (zip และรายการความเข้าใจแทน zipWith และ lambda, วิธีที่ดีกว่าในการสร้างบรรทัดแรก))

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)

ลองออนไลน์!

คำอธิบาย:

ฟังก์ชันi#nดึง ASCII-Triangle ของความสูง2^nหลังจากiทำซ้ำขั้นตอน

การเข้ารหัสที่ใช้เป็นการเข้ารหัสตำแหน่งที่ว่างภายใน1และตำแหน่งแบบเต็ม0ภายใน ดังนั้นบรรทัดแรกของสามเหลี่ยมจึงถูกเข้ารหัสเช่นเดียว[1,1,1..0..1,1,1]กับบรรทัด2^n-1ที่ทั้งสองด้านของศูนย์ ในการสร้างรายการนี้เราเริ่มต้นด้วยรายการx=1<$[2..2^n]คือรายการที่[2..2^n]มีทุกอย่างที่แมป1ไว้ จากนั้นเราสร้างรายการทั้งหมดเป็นx++0:x

โอเปอเรเตอร์k!p(คำอธิบายโดยละเอียดด้านล่าง) กำหนดดัชนีบรรทัดkและรายการที่สอดคล้องกันpสร้างรายการที่ไม่สิ้นสุดของบรรทัดที่ตามpมา เราเรียกใช้ด้วย1และบรรทัดเริ่มต้นที่อธิบายไว้ข้างต้นเพื่อรับสามเหลี่ยมทั้งหมดแล้วใช้เฉพาะ2^nเส้นแรกเท่านั้น จากนั้นเราก็พิมพ์แต่ละบรรทัดแทนที่1ด้วยช่องว่างและ0ด้วยM(โดยการเข้าถึงรายการ"M "ที่ตำแหน่ง0หรือ1)

ตัวดำเนินการk!pถูกกำหนดดังนี้:

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

ครั้งแรกที่เราสร้างสามรุ่นp: 1:pซึ่งเป็นpกับ1prepended, pตัวเองและtail p++[1]ซึ่งเป็นทุกอย่าง แต่องค์ประกอบแรกของpด้วยการ1ผนวก จากนั้นเรา zip ทั้งสามรายการให้เราได้อย่างมีประสิทธิภาพทุกองค์ประกอบของกับประเทศเพื่อนบ้านด้านซ้ายและขวาของพวกเขาเป็นp (l,m,r)เราใช้ list comprehension เพื่อคำนวณค่าที่เกี่ยวข้องในบรรทัดใหม่:

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

เพื่อให้เข้าใจถึงการแสดงออกนี้เราจำเป็นต้องตระหนักว่ามีสองกรณีพื้นฐานที่ควรพิจารณา: เราเพียงแค่ขยายบรรทัดก่อนหน้าหรือเราอยู่ในจุดที่จุดว่างในสามเหลี่ยมเริ่มต้น ในกรณีแรกเรามีจุดที่เติมหากจุดใด ๆ ในพื้นที่ใกล้เคียงเต็มไป สามารถคำนวณได้m*l*rดังนี้ ถ้าหนึ่งในสามนี้เป็นศูนย์ดังนั้นค่าใหม่จะเป็นศูนย์ อีกกรณีหนึ่งค่อนข้างยุ่งยาก ที่นี่เราจำเป็นต้องมีการตรวจจับขอบ ตารางต่อไปนี้ให้เพื่อนบ้านที่เป็นไปได้แปดแห่งด้วยค่าผลลัพธ์ในบรรทัดใหม่:

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

สูตรตรงไปตรงมาเพื่อให้ตารางนี้จะ1-m*r*(1-l)-m*l*(1-r)ง่ายm*(2*l*r-l-r)+1ขึ้น kตอนนี้เราต้องเลือกระหว่างทั้งสองกรณีซึ่งเป็นที่ที่เราจะใช้หมายเลขบรรทัด ถ้าmod k (2^(n-i)) == 0เราต้องใช้ตัวพิมพ์ที่สองมิฉะนั้นเราจะใช้ตัวพิมพ์แรก คำว่า0^(mod k(2^n-i))คือ0ถ้าเราต้องใช้กรณีแรกและ1ถ้าเราต้องใช้กรณีที่สอง เป็นผลให้เราสามารถใช้

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

รวม - ถ้าเราใช้กรณีแรกเราก็จะได้รับในขณะที่ในกรณีที่สองเป็นคำที่เพิ่มเติมจะถูกเพิ่มให้รวมใหญ่ของm*l*rm*(2*l*r-l-r)+1

C, 106 ตัวอักษร

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

(มันยังคงทำให้ฉันประหลาดใจว่าputs("")เป็นวิธีที่สั้นที่สุดในการสร้างบรรทัดใหม่ใน C)

โปรดทราบว่าคุณสามารถสร้างปะเก็นที่มีขนาดใหญ่ขึ้น (หรือเล็กกว่า) ได้โดยการแทนที่การทดสอบ32ในforลูปด้วยพลังงานที่มีขนาดใหญ่กว่า (เล็กกว่า) สองเท่าตราบใดที่คุณยังแทนที่33ตรงกลางprintf()ด้วย power-of-two-plus- หนึ่ง.