シェルピンスキーの三角形は、三角形を取り、高さと幅を1/2に減らし、結果の三角形のコピーを3つ作成し、各三角形が角の他の2つと接触するように配置することで作成されるフラクタルです。以下に示すように、このプロセスが結果の三角形で何度も繰り返され、シェルピンスキー三角形が生成されます。

シェルピンスキーの三角形を生成するプログラムを作成します。実際の三角形を描画するか、ランダムアルゴリズムを使用して画像を生成することにより、パターンを生成する任意の方法を使用できます。出力が上記の最後の図に似ている限り、ピクセル、ASCIIアートなど、必要なものを何でも描画できます。最も少ないキャラクターが勝ちます。

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定数を優先して削除することにより、3文字を節約できます64が、結果は小さくなります。8詳細が不十分なため、このオプションは数えません。

256以上のサイズには<canvas>、キャンバスサイズをデフォルトから増やすための属性が必要であることに注意してください。

GolfScript（43 42文字）

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

出力：

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

三角形を大きくするには、「3」を大きな数値に変更します。

パイソン（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]

これにより、0と1の2Dテーブルが生成され、1がシェピンスキー三角形を描きます。

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

簡単な説明：

動詞(,~,.~)はここで仕事をしているものです。これは、最初に引数をそれ自体にステッチし（-> ）、次に元の引数を出力に追加するフックです。,.ooo

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

など。次に、appendの斜め副詞を使用,/.して、行を斜めに読み取り、三角形をまっすぐにします。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+：文字配列から適切な値を選択するために1を追加します
• ' ○'[... ]：スペース（三角形の一部ではない）または円（三角形の一部である場合）を出力します

出力：

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

ハスケル（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 4は：

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

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

パイソン（42）

私はもともと、ブースビーソリューション（実際にルール18を使用しています）に関するいくつかの提案を投稿したかったのですが、コメントするのに十分な評判がなかったので、別の答えにしました。彼はアプローチを変えたので、いくつかの説明を追加しました。私の提案は：

1. '' .join（map（str、x））の代わりに '％d' * 64％tuple（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

しかし、最初に整数配列の代わりに倍長整数を使用し、バイナリ表現（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文字）で既にサポートされている8進数表現を印刷します。

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をエミュレートする別のCG問題に取り組んでいるときにこれを見つけました。付属のテキストファイルにはDavid Staffordがクレジットされていますが、それが私が思いつく最高のものです。

賢くて短いので、これを投稿します。あなたがそれを見たいと思ったのです。

オーバーラップするオペコードを使用して、より少ないスペースでより多くの命令をパックします。驚くほど賢い。マシンコードは次のとおりです。

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

これは、^ i & jきれいな出力を印刷するためにHTMLの答えのトリックを使用します。さらに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ます。しかし、ルックスにイワナを無駄遣いしているのは、私にはアンゴルフィッシュのようです。

Uい出力：

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

実際に見た目が好きです。しかし、それがきれいだと主張するなら、4つの文字をドッキングできます。きれいな出力：

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

古い108文字のセルオートマトンバージョンを残します。

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バイト

MsDos iの非常に小さなイントロに特化したサイズコーダーとして、わずか10バイトしか占有しないプログラムを思いついた。

16進数で：

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

私がコーディングした最初のバージョンは、サイズが16バイトの「Colpinski」であり、キーボードとマウスで色を変更できるようにインタラクティブでさえありました。「Frag」（別のサイズコーダー）とともに、その1つを13バイトに減らし、コアルーチンのみを含む10バイトのプログラムを可能にしました。

物事がアニメーション化されるともう少し面白くなるので、別のバージョンであるZoompinski 64について説明します。512バイトで「Zoompinski C64」の正確な動作を模倣しようとします。

エレガンス、色、対称性を失いながら、これをさらに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出力：

これは、すでに描画されているものを再帰的に3倍して図形を描画しています。

最初のステップは線を描くことです。行はユーザーパスとして保存され、そのたびに120度回転した後、ユーザーパスがさらに2回追加されます。[2 0 0 2 7 4]concat「回転点」を、既存の三角形の複製で囲まれる次の大きな白い「中心三角形」の中心に移動します。ここで、ステップ1に戻ります（回転によって3倍になる上昇を作成します）。

反復回数は、3行目の最初の数によって制御されます。

J（9文字）

最もasiい、あなたは本当に出力を見るために目を細める必要があります;）

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

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

説明

• 1 2⍴'/\'：1×2文字行列を作成します /\
• {((-1⌷⍴⍵)⌽⍵,∊⍵)⍪⍵,⍵}：右側の引数の両側に空白を埋めて倍の幅の行列を作成し、次に右側の引数自体を底に重ねる関数。
  例えば/\になります

 / \ 
/ \ / \

• ⍣⎕：関数（ユーザー入力）を繰り返します。

出力例

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

斜め三角形（28 23-char）

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

説明

• 1 1⍴'○'：1×1文字行列を作成します ○
• {(⍵,∊⍵)⍪⍵,⍵}：右側の引数に空白を埋めて、倍の幅の行列を作成し、右側の引数自体を底に重ねた関数。
  例えば○になります

○ 
○○

• ⍣⎕：関数（ユーザー入力）を繰り返します。

出力例

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

パイソン（75）

私はパーティーに2年遅れていますが、私は誰もまだこのアプローチを取っていないことに驚いています

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)行3を使用して3つの表示レベルを持つ16x16ピクセル画像を取得するか、イテレータに別の文字を追加して2 ^ 16 x 2 ^ 16 = 4.3ギガピクセルの画像と15の三角形レベルで2文字を保存できます。

ロゴ、75文字

最初の関数だけに59文字、2番目の関数はサイズと反復回数/深さで最初の関数を呼び出します。したがって、コマンドでインタープリターから最初の関数を呼び出すことができます：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)

オンラインで試す

シェルピンスキー三角形を埋めるフラクタル線を描く

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]

シェルピンスキー四面体は、同様の方法で描くことができます。

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

J、³⁷ 35バイト

-FrownyFrogのおかげで2バイト

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

オンラインでお試しください！

これは、ピーターテイラーのアスキーアートバージョンをJに変換したものです。バイト数を節約するために、見栄えの悪いバージョンを使用できましたが、なぜでしょうか。

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

GollyのLuaスクリプト、54バイト

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

Gollyは、LuaおよびPythonスクリプトをサポートするセルラーオートマトンシミュレータです。

このスクリプトは、ルールをWolfram Rule 60に設定し、セルを（0,0）に1に設定し、512ステップを実行します。

追記、 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

文字列と再帰を使用した書き換えは、まったく同じカウントになります。しかし、マクロアプローチの深さの制限は克服されています。

編集： fillよりも短いですstroke。

インデントとコメント。

%!
[   % 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バイト

これを追加しますが、これは主に、このサイトの漸近線で回答が多かれ少なかれ見られないためです。素晴らしいフォーマットと一般性のためにいくつかの無駄なバイトがありますが、私はそれに耐えることができます。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);

または無料で読みやすい

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バイト

（Laikoniのおかげで12バイト、（zipWithとlambdaの代わりにzipとリストの内包表記、最初の行を生成するより良い方法））

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は、反復ステップ2^n後に高さのASCII-Triangleを描画しiます。

内部的に使用されるエンコーディングは、空の位置をとして1、完全な位置をとしてエンコードします0。したがって、三角形の最初の行のように符号化される[1,1,1..0..1,1,1]と2^n-1、ゼロの両側もの。このリストを作成するには、listから始めます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]]

まず、我々は3つのバージョンを生成p：1:pあるpと1先頭に付加、p自身とtail p++[1]そのすべてが、最初の要素であるpと、1追加します。次に、これら3つのリストを圧縮して、のすべての要素pとその左右の隣接要素を効果的に提供し(l,m,r)ます。リスト内包表記を使用して、新しい行の対応する値を計算します。

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

この表現を理解するために、考慮すべき2つの基本的なケースがあることを認識する必要があります。前の行を単純に展開するか、三角形の空のスポットが始まる点です。最初のケースでは、近隣のスポットのいずれかが満たされている場合、満たされたスポットがあります。これは次のように計算できますm*l*r。これら3つのいずれかがゼロの場合、新しい値はゼロです。他のケースは少し複雑です。ここでは、基本的にエッジ検出が必要です。次の表は、新しい行に結果の値を持つ8つの可能な近傍を示しています。

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ます。今、我々は行番号を使用する場所である、これらの2つの場合の間で選択する必要がありますk。の場合mod k (2^(n-i)) == 0、2番目のケースを使用する必要があり、そうでない場合は、最初のケースを使用します。0^(mod k(2^n-i))したがって、この用語は0、最初のケースを使用する必要がある場合と1、2番目のケースを使用する必要がある場合です。その結果、使用できます

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

合計で-最初のケースを使用する場合、単にを取得m*l*rしますが、2番目のケースでは、追加の用語が追加され、総計が得られm*(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、あなたも交換する限り、2の大きい方（小さい）パワーとループのテストを33途中でprintf()電源の-2-plus-と1。