Трикутник Серпінського - це фрактал, утворений взяттям трикутника, зменшення висоти та ширини на 1/2, створення 3 копій отриманого трикутника, і розміщуйте їх таким, щоб кожен трикутник торкався інших двох на кутку. Цей процес повторюється знову і знову з отриманими трикутниками для отримання трикутника Серпінського, як показано нижче.

Напишіть програму для генерації трикутника Серпінського. Ви можете використовувати будь-який метод, який ви хочете генерувати візерунок, або шляхом малювання фактичних трикутників, або за допомогою випадкового алгоритму для створення зображення. Ви можете малювати пікселі, мистецтво 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||, що створює «правильний трикутник Сєрпінського»; і 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" на більшу кількість для більшого трикутника.

Пітон (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, де 1-ма намалюють Сярпінський трикутник.

Пітона, 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

Потім я використав косий прислівник на додаванні, ,/.щоб прочитати рядки по діагоналі, щоб випрямити (іш) трикутник. Мені це не потрібно було робити, як вказує випадкова особа . Я міг би просто перевернути |.партію, щоб отримати той самий результат. Ще краще, я міг би просто використати (,,.~)^: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+: додайте одне, щоб вибрати правильне значення з масиву символів
• ' ○'[... ]: виведіть пробіл (не частина трикутника) або коло (коли це частина трикутника)

Вихід:

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

Хаскелл (291)

Я не дуже добре в гольф-кодах 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

Вихід 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. використовуйте '% d' * 64% кортеж (x) замість '' .join (карта (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 байт.

ПРИМІТКА. Це не мій код, і його не слід сприймати як відповідь . Я виявив це, працюючи над іншою проблемою CG, щоб імітувати 8086 CPU . Текстовий файл, що входить в комплект даних, заслуховує Девіда Стаффорда , але це найкраще, що я міг придумати.

Я публікую це, тому що це розумно, коротко, і я думав, що ви захочете це побачити.

Для використання додаткових інструкцій, що перекриваються, використовується менша кількість вказівок. Дивовижно розумний. Ось код машини:

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

Цей використовується хитрість відповіді 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-літрову, мобільну версію автоматів.

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, мені вдалося придумати програму, яка займає всього 10 байт.

у шістнадцятковій формі:

04 13 CD 10 20 E9 B4 0C E2 F6

в зоні:

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

Перша версія, яку я кодувала, була "Колпінський", розміром 16 байт, і навіть інтерактивною, щоб ви могли змінити колір за допомогою клавіатури та миші. Разом з "Frag" - ще одним кодером розмірів - ми знизили його до 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 матрицю символів ○
• {(⍵,∊⍵)⍪⍵,⍵}: Функція, яка розміщує правий аргумент праворуч із пробілами, щоб створити матрицю, подвійну настільки широку, а потім промальовує правий аргумент сам, подвійний на нижню.
  Напр. ○Став би

○ 
○○

• ⍣⎕: Повторіть функцію (введення користувача) разів.

Приклад виведення

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

Пітон (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)третій рядок, щоб отримати зображення 16х16 пікселів з трьома видимими рівнями або додати інший знак до ітератора і в кінцевому підсумку з зображенням 2 ^ 16 x 2 ^ 16 = 4,3 гігапікселя та 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

матлаб 56

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

J (18 символів)

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

Результат

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

Пітон (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)

Спробуйте в Інтернеті

Намалюйте фрактальну лінію, що заповнює Серпінський трикутник

Математика 67

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

Математика 92

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

Математика , 29 байт

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

Тетраедр Сєрпінського можна намалювати аналогічно:

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

J , ³⁷ 35 байт

-2 байти завдяки FrownyFrog

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

Спробуйте в Інтернеті!

Це мистецька версія Пітера Тейлора, перетворена на Дж. Могла зберегти байти з менш гарною версією, але чому?

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

Сценарій Lua в Голлі , 54 байти

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

Голлі - це мобільний симулятор з підтримкою сценаріїв Lua та Python.

Цей скрипт встановлює правило Wolfram Правило 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);

Отже, асимптота - це акуратна мова векторної графіки з дещо подібним синтаксисом С. Досить корисний для дещо технічних діаграм. Висновок, звичайно, у векторному форматі за замовчуванням (eps, pdf, svg), але може бути перетворений в основному все, що підтримує Imagemagick. Вихід:

Haskell , 166 154 байт

(-12 байт завдяки Laikoni, (розуміння zip та списку замість zipWith та лямбда, кращий спосіб генерування першого рядка))

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-трикутник висоти 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з попередньо створеною 1, pсама, і tail p++[1]яка є лише першим елементом p, із 1доданим. Потім ми зашифровуємо ці три списки, даючи нам фактично всі елементи pз їх лівими та правими сусідами, як (l,m,r). Ми використовуємо розуміння списку, щоб потім обчислити відповідне значення у новому рядку:

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*r, тоді як у другому випадку додається додатковий термін, що дає загальну суму 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тестовому циклі з більшою (меншою) ступенем двійки, до тих пір , як ви можете також замінити 33в середині printf()з владою двоє дітей -плюс один.