Tam giác Sierpinky là một hình nhỏ được tạo ra bằng cách lấy một hình tam giác, giảm 1/2 chiều cao và chiều rộng, tạo 3 bản sao của tam giác thu được và đặt chúng như vậy mỗi hình tam giác chạm vào hai hình tam giác khác trên một góc. Quá trình này được lặp đi lặp lại nhiều lần với các tam giác thu được để tạo ra tam giác Sierpinki, như minh họa dưới đây.

Viết chương trình tạo tam giác Sierpinki. Bạn có thể sử dụng bất kỳ phương pháp nào bạn muốn tạo mẫu, bằng cách vẽ các hình tam giác thực tế hoặc bằng cách sử dụng một thuật toán ngẫu nhiên để tạo ra hình ảnh. Bạn có thể vẽ bằng pixel, nghệ thuật ascii hoặc bất cứ thứ gì bạn muốn, miễn là đầu ra trông giống với hình ảnh cuối cùng được hiển thị ở trên. Ít nhân vật nhất chiến thắng.

HTML + JavaScript, 150 ký tự (xem ghi chú cho 126 ký tự)

Khoảng trắng được chèn để dễ đọc và không được tính.

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

Cốt lõi của nó là áp dụng quy tắc tô màu các pixel mà x & y == 0theo điều kiện x&y||, nó tạo ra một tam giác bên phải Sierpinki đúng; và x-~y/2,k-ylà một phép biến đổi tọa độ để tạo ra màn hình gần bằng nhau.

Phiên bản ít chính xác hơn (HTML-khôn ngoan) là 126 ký tự:

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

(Cách mà điều này ít đúng hơn là nó bỏ qua titlephần tử và thẻ kết thúc của canvasphần tử, cả hai đều được yêu cầu cho một tài liệu chính xác mặc dù bỏ qua chúng không làm thay đổi cách hiểu của tài liệu.)

Ba ký tự có thể được lưu bằng cách loại bỏ có klợi cho hằng số 64, với chi phí cho kết quả nhỏ hơn; Tôi sẽ không tính 8tùy chọn vì nó không đủ chi tiết.

Lưu ý rằng kích thước 256 hoặc cao hơn yêu cầu các thuộc tính trên <canvas>để tăng kích thước vải từ mặc định.

GolfScript ( 43 42 ký tự)

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

Đầu ra:

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

Thay đổi "3" thành số lớn hơn cho hình tam giác lớn hơn.

Con trăn (234)

Chơi golf tối đa, hình ảnh nhỏ:

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

Yêu cầu python3-cairo.

Để có được một hình ảnh lớn đẹp, tôi cần tới 239 ký tự.

Toán học - 32 ký tự

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

Toán học - 37 ký tự

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

Điều này sẽ tạo ra một bảng 2D gồm 0 và 1, trong đó 1s đang vẽ Tam giác Sierpinki.

Con trăn, 101 86

Sử dụng quy tắc 90 tự động.

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

Cái này dài hơn, nhưng đẹp hơn.

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

Chỉnh sửa: chơi với các chuỗi trực tiếp, loại bỏ các lát cắt dài đáng ghét, làm cho đầu ra đẹp hơn.

Đầu ra:

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

J

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

Không lý tưởng, vì hình tam giác bị lệch và theo sau là rất nhiều khoảng trắng - nhưng dù sao tôi cũng thấy thú vị.

Đầu ra:

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

Giải thích nhanh:

Động từ (,~,.~)là những gì đang làm công việc ở đây. Đó là một cái móc đầu tiên khâu ,.đối số vào chính nó ( o-> oo) và sau đó nối thêm đối số ban đầu vào đầu ra:

oo

trở thành

oo
o

Động từ này được lặp lại 6 lần ^:6với đầu ra của mỗi lần lặp trở thành đầu vào của lần lặp tiếp theo. Vì thế

oo
o

trở thành

oooo
o o
oo
o

lần lượt trở thành

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

v.v ... Sau đó, tôi đã sử dụng trạng từ xiên trên append ,/.để đọc các hàng theo đường chéo để làm thẳng (ish) hình tam giác. Tôi không cần phải làm điều này, như ngẫu nhiên chỉ ra. Tôi có thể đã đảo ngược |.rất nhiều để có được kết quả tương tự. Thậm chí tốt hơn, tôi có thể chỉ cần sử dụng (,,.~)^:6,'o'để lưu hoàn toàn bước ngược lại.

Ah tốt, bạn sống và học hỏi. :-)

APL (51)

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

Giải trình:

• A←67⍴0: A là một vectơ của 67 số không
• A[34]←1: phần tử thứ 34 là 1
• {...}A: bắt đầu bằng A, làm:
• ~⊃⍵:: nếu phần tử đầu tiên của hàng hiện tại bằng không
• ⍵,∇: thêm hàng hiện tại vào câu trả lời và lặp lại với:
• (1⌽⍵)≠¯1⌽⍵: vectơ trong đó mỗi phần tử là XOR của các lân cận của nó trong thế hệ trước
• ⋄⍬: nếu không, chúng ta đã xong
• 32 67⍴: định dạng này trong ma trận 67x32
• 1+: thêm một để chọn đúng giá trị từ mảng ký tự
• ' ○'[... ]: xuất ra một khoảng trắng (không phải là một phần của tam giác) hoặc một hình tròn (khi nó là một phần của tam giác)

Đầu ra:

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

Haskell (291)

Tôi không giỏi chơi golf 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

Đầu ra solve 4là:

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

QBasic 151 Nhân vật

Ví dụ, đây là cách nó có thể được thực hiện trong 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

Con trăn (42)

Ban đầu tôi muốn đăng một vài gợi ý về giải pháp boothbys (người thực sự sử dụng quy tắc 18 :), nhưng tôi không đủ danh tiếng để bình luận, vì vậy tôi đã đưa nó vào một câu trả lời khác. Kể từ khi anh ấy thay đổi cách tiếp cận của mình, tôi đã thêm một số lời giải thích. Gợi ý của tôi sẽ là:

1. sử dụng '% d' * 64% tuple (x) thay vì '' .join (map (str, x)
2. thay đổi số không thay vì bọc danh sách xung quanh

mà sẽ dẫn đến mã sau đây (93 ký tự):

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

Nhưng tôi đã tối ưu hóa hơn nữa, trước tiên bằng cách sử dụng một dấu dài thay vì một mảng số nguyên và chỉ in biểu diễn nhị phân (75 ký tự):

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

Và cuối cùng bằng cách in biểu diễn bát phân, đã được hỗ trợ bởi phép nội suy printf (42 ký tự):

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

Tất cả trong số họ sẽ in:

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

Tất nhiên cũng có một giải pháp đồ họa (131 ký tự):

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

:CƯỜI MỞ MIỆNG

8086 Mã máy - 30 byte.

LƯU Ý: Đây không phải là mã của tôi và không được chấp nhận làm câu trả lời . Tôi đã tìm thấy điều này trong khi làm việc với một vấn đề CG khác để mô phỏng CPU 8086 . Các tập tin văn bản bao gồm David Stafford , nhưng đó là điều tốt nhất tôi có thể đưa ra.

Tôi đang đăng bài này vì nó thông minh, ngắn và tôi nghĩ bạn muốn xem nó.

Nó sử dụng các opcodes chồng chéo để đóng gói nhiều hướng dẫn hơn trong một không gian nhỏ hơn. Tuyệt vời thông minh. Đây là mã máy:

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

Một giải mã thẳng lên trông như thế này:

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

Khi chạy, khi bước nhảy ở 0x0115 xảy ra, hãy chú ý nó nhảy trở lại 0x010C, ngay giữa một lệnh trước đó:

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]

Xuất sắc! Hy vọng các bạn không phiền tôi chia sẻ điều này. Tôi biết đó không phải là một câu trả lời, nhưng nó rất quan tâm đến thử thách.

Đây là hành động:

C 127 119 116 108 65

Cái này sử dụng mánh khóe của câu trả lời HTML ^ i & jđể có được nó để in đầu ra đẹp sẽ mất thêm 1 char (bạn có thể nhận được đầu ra thực sự xấu xí bằng cách hy sinh a^).

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

Để làm cho nó khá biến (32^i&j)đến (32|!(i&j))và biến nó từ ++i<ađến ++i<=a. Tuy nhiên, lãng phí ký tự vào ngoại hình có vẻ vô dụng với tôi.

Sản lượng xấu:

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

Tôi thực sự giống như nó trông như thế nào. Nhưng nếu bạn khăng khăng nó đẹp, bạn có thể cập bến bốn ký tự. Đầu ra khá:

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

Rời khỏi phiên bản 108 char cũ, di động.

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

Vì vậy, tôi không nghĩ rằng tôi sẽ nhận được nó ngắn hơn nhiều so với điều này vì vậy tôi sẽ giải thích mã. Tôi sẽ để lại lời giải thích này, vì một số thủ thuật có thể hữu ích.

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
}

Một số đầu ra

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

Mã 80x86 / MsDos - 10 byte

Là một sizecoder chuyên cho các phần giới thiệu rất nhỏ trên MsDos, tôi đã quản lý để đưa ra một chương trình chỉ chiếm 10 byte.

trong hex:

04 13 CD 10 20 E9 B4 0C E2 F6

trong asm:

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

Phiên bản đầu tiên tôi mã hóa là "Colpinki" có kích thước 16 byte và thậm chí tương tác theo cách bạn có thể thay đổi màu sắc bằng bàn phím và chuột. Cùng với "Frag" - một sizecoder khác - chúng tôi đã đưa nó xuống còn 13 byte, cho phép một chương trình 10 byte chỉ chứa thường trình lõi.

Sẽ thú vị hơn một chút khi mọi thứ được làm động, vì vậy tôi sẽ đề cập đến một phiên bản khác, Zoompinski 64 - cố gắng bắt chước hành vi chính xác của "Zoompinski C64" trong 512 byte - cũng cho MsDos, kích thước 64 byte như tên cho thấy.

Có thể tối ưu hóa việc giảm giá thêm 31 Byte này, trong khi mất đi sự thanh lịch, màu sắc và tính đối xứng (nguồn và thực thi có sẵn phía sau liên kết ở trên)

Tải về bản gốc và nhận xét về "Pouet"

PostScript, 120 ký tự

-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

Đầu ra Ghostscript:

Đây là vẽ hình bằng cách tăng gấp ba lần những gì đã vẽ.

Bước đầu tiên là vẽ một đường. Dòng được lưu dưới dạng đường dẫn người dùng, sau đó đường dẫn người dùng được thêm hai lần nữa sau khi xoay 120 độ mỗi lần. [2 0 0 2 7 4]concatdi chuyển "điểm xoay" đến trung tâm của "tam giác trung tâm" lớn màu trắng tiếp theo được bao quanh bởi các bản sao của tam giác mà chúng ta đã có. Ở đây, chúng tôi quay lại bước 1 (tạo ra một upath tăng gấp ba lần khi quay).

Số lần lặp được kiểm soát bởi số đầu tiên trong dòng 3.

J (9 ký tự)

Dễ dàng xấu nhất, bạn thực sự cần phải nheo mắt để xem đầu ra;)

2|!/~i.32

tạo ra đầu ra

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

Tất nhiên bạn có thể hiển thị nó bằng đồ họa:

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

APL, 37 32 ( 28 23)

Tam giác thẳng đứng ( 37 32-char)

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

Giải trình

• 1 2⍴'/\': Tạo ma trận ký tự 1 × 2 /\
• {((-1⌷⍴⍵)⌽⍵,∊⍵)⍪⍵,⍵}: Một hàm đệm đối số đúng ở cả hai bên với khoảng trống để tạo ma trận gấp đôi chiều rộng, sau đó ghép chính đối số phải nhân đôi lên phía dưới.
  Ví dụ /\sẽ trở thành

 / \ 
/ \ / \

• ⍣⎕: Lặp lại chức năng (đầu vào của người dùng) lần.

Ví dụ đầu ra

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

Tam giác xiên ( 28 23-char)

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

Giải thích

• 1 1⍴'○': Tạo ma trận ký tự 1 × 1 ○
• {(⍵,∊⍵)⍪⍵,⍵}: Một hàm đệm đối số bên phải với các khoảng trống để tạo ma trận gấp đôi chiều rộng, sau đó ghép chính đối số phải nhân đôi lên phía dưới.
  Ví dụ ○sẽ trở thành

○ 
○○

• ⍣⎕: Lặp lại chức năng (đầu vào của người dùng) lần.

Ví dụ đầu ra

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

Con trăn (75)

Tôi dự tiệc muộn hai năm, nhưng tôi ngạc nhiên vì chưa có ai thực hiện phương pháp này

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

Sử dụng sản phẩm Kronecker để thay thế một ma trận bằng nhiều bản sao của chính nó.

Tôi có thể lưu hai ký tự bằng cách sử dụng x=kron(x,x);x=kron(x,x)trong dòng ba để có được hình ảnh 16x16 pixel với ba mức có thể nhìn thấy hoặc thêm một ký tự khác vào trình lặp và kết thúc với hình ảnh 2 ^ 16 x 2 ^ 16 = 4.3 Gigapixel và 15 cấp độ tam giác.

Logo, 75 ký tự

59 ký tự cho hàm đầu tiên, ký tự thứ hai gọi hàm thứ nhất với kích thước và độ sâu / số lần lặp. Vì vậy, bạn chỉ có thể gọi hàm đầu tiên từ trình thông dịch bằng lệnh: e 99 5 hoặc bất kỳ kích thước nào bạn muốn xuất

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

chiếu 56

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

J (18 ký tự)

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

Kết quả

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

Python (90 ký tự)

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)

Dùng thử trực tuyến

Vẽ đường fractal điền Tam giác Sierpinky

Toán học 67

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

Toán học 92

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

Toán học , 29 byte

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

Tứ diện Sierpinki có thể được vẽ theo cách tương tự:

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

J , ³⁷ 35 byte

-2 byte nhờ FrownyFrog

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

Hãy thử trực tuyến!

Đây là phiên bản nghệ thuật ascii của Peter Taylor được chuyển đổi thành J. Có thể lưu byte bằng một phiên bản ít đẹp hơn, nhưng tại sao?

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

Tập lệnh Lua trong Golly , 54 byte

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

Golly là một trình giả lập automata di động với sự hỗ trợ kịch bản Lua và Python.

Kịch bản lệnh này đặt quy tắc thành Quy tắc Wolfram 60, đặt ô ở (0,0) thành 1 và chạy 512 bước.

Bản thảo, 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

Viết lại bằng cách sử dụng các chuỗi và đệ quy kết thúc ở cùng một số lượng chính xác. Nhưng những hạn chế về chiều sâu của phương pháp vĩ mô được khắc phục.

Chỉnh sửa: fill ngắn hơn stroke.

Thụt lề và bình luận.

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

Thêm 0 setlinewidthcho một ấn tượng tốt hơn về cách sâu này đi.

APL (Dyalog Classic) , 12 byte

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

Hãy thử trực tuyến!

Tiệm cận, 152 byte

Tôi sẽ thêm điều này, chủ yếu là vì tôi đã thấy ít nhiều không có câu trả lời nào trong tiệm cận trên trang web này. Một vài byte lãng phí cho định dạng đẹp và tổng quát, nhưng tôi có thể sống với điều đó. Thay đổi A, B và C sẽ thay đổi vị trí của các góc của tam giác chứa, nhưng có lẽ không theo cách bạn nghĩ. Tăng số lượng bất đẳng thức để tăng độ sâu.

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

hoặc không hiểu và có thể đọc đượ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);

Vì vậy, tiệm cận là một ngôn ngữ đồ họa vector gọn gàng với cú pháp hơi giống C. Khá hữu ích cho các sơ đồ kỹ thuật. Đầu ra tất nhiên là ở định dạng vector theo mặc định (eps, pdf, svg) nhưng có thể được chuyển đổi thành cơ bản mọi thứ mà hình ảnh hỗ trợ. Đầu ra:

Haskell , 166 154 byte

(-12 byte nhờ Laikoni, (zip và hiểu danh sách thay vì zipWith và lambda, cách tốt hơn để tạo dòng đầu tiên))

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)

Hãy thử trực tuyến!

Giải trình:

Hàm này i#nvẽ một tam giác chiều cao ASCII 2^nsau icác bước lặp.

Mã hóa được sử dụng nội bộ mã hóa các vị trí trống như 1và các vị trí đầy đủ như 0. Do đó, dòng đầu tiên của tam giác được mã hóa như [1,1,1..0..1,1,1]với 2^n-1các dòng ở cả hai phía của số không. Để xây dựng danh sách này, chúng tôi bắt đầu với danh sách x=1<$[2..2^n], tức là danh sách [2..2^n]với mọi thứ được ánh xạ tới 1. Sau đó, chúng tôi xây dựng danh sách đầy đủ nhưx++0:x

Toán tử k!p(giải thích chi tiết bên dưới), được đưa ra một chỉ mục dòng kvà tương ứng ptạo ra một danh sách vô hạn các dòng tiếp theo p. Chúng tôi gọi nó với 1và dòng bắt đầu được mô tả ở trên để có được toàn bộ tam giác, và sau đó chỉ lấy các 2^ndòng đầu tiên . Sau đó, chúng tôi chỉ cần in từng dòng, thay thế 1bằng khoảng trắng và 0bằng M(bằng cách truy cập danh sách "M "tại vị trí 0hoặc 1).

Toán tử k!pđược định nghĩa như sau:

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

Đầu tiên, chúng tôi tạo ra ba phiên bản p: 1:pđó là pvới một bản được đặt 1trước, pbản thân nó và tail p++[1]tất cả mọi thứ trừ phần tử đầu tiên p, với phần được 1nối thêm. Sau đó, chúng tôi nén ba danh sách này, cung cấp cho chúng tôi hiệu quả tất cả các yếu tố pvới hàng xóm bên trái và bên phải của họ, như (l,m,r). Chúng tôi sử dụng một sự hiểu biết danh sách để sau đó tính toán giá trị tương ứng trong dòng mới:

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

Để hiểu biểu thức này, chúng ta cần nhận ra có hai trường hợp cơ bản cần xem xét: Hoặc là chúng ta chỉ cần mở rộng dòng trước hoặc chúng ta đang ở điểm bắt đầu một điểm trống trong tam giác. Trong trường hợp đầu tiên, chúng tôi có một vị trí đầy nếu bất kỳ điểm nào trong khu phố được lấp đầy. Điều này có thể được tính như m*l*r; nếu bất kỳ một trong ba số này bằng 0, thì giá trị mới bằng không. Các trường hợp khác là một chút phức tạp hơn. Ở đây, về cơ bản chúng ta cần phát hiện cạnh. Bảng sau đây cung cấp tám vùng lân cận có thể có giá trị kết quả trong dòng mới:

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

Một công thức đơn giản để mang lại bảng này sẽ được 1-m*r*(1-l)-m*l*(1-r)đơn giản hóa m*(2*l*r-l-r)+1. Bây giờ chúng ta cần chọn giữa hai trường hợp này, đó là nơi chúng ta sử dụng số dòng k. Nếu mod k (2^(n-i)) == 0, chúng ta phải sử dụng trường hợp thứ hai, nếu không, chúng ta sử dụng trường hợp thứ nhất. 0^(mod k(2^n-i))Do đó, thuật ngữ này là 0nếu chúng ta phải sử dụng trường hợp thứ nhất và 1nếu chúng ta phải sử dụng trường hợp thứ hai. Kết quả là chúng ta có thể sử dụng

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

tổng cộng - nếu chúng ta sử dụng trường hợp đầu tiên, chúng ta chỉ cần nhận được m*l*r, trong khi trong trường hợp thứ hai, một thuật ngữ bổ sung được thêm vào, đưa ra tổng số lớn m*(2*l*r-l-r)+1.

C, 106 ký tự

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

(Tôi vẫn thấy vui vì đó puts("")là cách ngắn nhất để tạo ra một dòng mới trong C.)

Lưu ý rằng bạn có thể tạo các miếng đệm lớn hơn (hoặc nhỏ hơn) bằng cách thay thế thử nghiệm 32trong forvòng lặp bằng công suất lớn hơn (nhỏ hơn) bằng hai, miễn là bạn cũng thay thế 33ở giữa printf()bằng công suất cộng hai một.