Codegolf - Нарисуйте Треугольник Серпинского

Серпинский треугольник фрактал, созданный путем уменьшения высоты и ширины треугольника на 1/2, создания 3 копий полученного треугольника и размещения их так, чтобы каждый треугольник касался двух других в углу. Этот процесс повторяется снова и снова с полученными треугольниками, образуя треугольник Серпинского, как показано ниже.

Напишите программу построения треугольника Серпинского. Вы можете использовать любой метод создания шаблона: либо рисуя настоящие треугольники, либо используя случайный алгоритм для создания изображения. Вы можете рисовать в пикселях, в формате ASCII или в любом другом формате, при условии, что результат будет похож на последнее изображение, показанное выше. Побеждает наименьшее количество персонажей.

#код-гольф #математика #колмогоров-сложность #фрактал

HTML + JavaScript, 150 символов (126 символов см. в примечаниях)

Пробелы вставлены для удобства чтения и не учитываются.

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
○ 
○○
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Суть его заключается в применении правила окраски пикселей, для которого

 
 
 /\ 
/\/\
 
 

 
 
 
 
 
 
 
 
 
 
 
 
 

○                                 

○ ○                                

○   ○                               

○ ○ ○ ○                              

○       ○                             

○ ○     ○ ○                            

○   ○   ○   ○                           

○ ○ ○ ○ ○ ○ ○ ○                          

○               ○                         

○ ○             ○ ○                        

○   ○           ○   ○                       

○ ○ ○ ○         ○ ○ ○ ○                      

○       ○       ○       ○                     

○ ○     ○ ○     ○ ○     ○ ○                    

○   ○   ○   ○   ○   ○   ○   ○                   

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

○                               ○                 

○ ○                             ○ ○                

○   ○                           ○   ○               

○ ○ ○ ○                         ○ ○ ○ ○              

○       ○                       ○       ○             

○ ○     ○ ○                     ○ ○     ○ ○            

○   ○   ○   ○                   ○   ○   ○   ○           

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

○               ○               ○               ○         

○ ○             ○ ○             ○ ○             ○ ○        

○   ○           ○   ○           ○   ○           ○   ○       

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

○       ○       ○       ○       ○       ○       ○       ○     

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

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

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

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 start:
lda #$e1
sta $0
lda #$01
sta $1
ldy #$20
w_e:
ldx #$00
eor ($0, x)
sta ($0),y
inc $0
bne w_e
inc $1
ldx $1
cpx #$06
bne w_e
rts
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Менее правильная (с точки зрения HTML) версия состоит из 126 символов:

(Это менее правильно, поскольку здесь опускается %! [ % 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 element and the end tag of the stroke оба элемента необходимы для правильного документа, хотя их пропуск не меняет интерпретация документа.)

Три персонажа можно спасти, устранив fill in favor of the constant [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 , ценой меньшего результата; я бы не стал считать printf() option as it has insufficient detail.

Обратите внимание, что для размера 256 или выше требуются атрибуты на 33 to increase the canvas size from the default.

GolfScript (43 42 символа)

Выход:

Измените цифру «3» на большее число, чтобы треугольник стал больше.

Питон (234)

Максимальная игра в гольф, крошечное изображение:

Требует 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?"/__\\":"/\\");} .

Чтобы получить красивое большое изображение, мне нужно было 239 персонажи.

Математика - 32 символа

Математика - 37 символов

Это создаст двумерную таблицу 0 и 1, где 1 рисуют треугольник Серпинского.

Питон, 101 86

Использует автомат по правилу 90.

Это дольше, но красивее.

Изменить: напрямую играть со строками, избавиться от неприятно длинной нарезки, сделать вывод более красивым.

Выход:

Дж

Не идеально, так как треугольник перекошенный и за ним следует много пробелов, но, тем не менее, мне показалось интересным.

Выход:

Краткое объяснение:

Глагол Image3D[1-Array[BitXor,{2,2,2}^7,0]] is what's doing the work here. It's a крюк какой первый стежок Image@Array[BitAnd,{2,2}^9,0] the argument to itself ( ×.≥∘⍉⍨↑,⍳⎕⍴2 -> 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) ) and then appends the original argument to the output:

становится

Этот глагол повторяется 6 раз 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 with the output of each iteration becoming the input of the next iteration. So

становится

что в свою очередь становится

и т. д. Затем я использовал наклонное наречие при добавлении ○ ○○ ○ ○ ○○○○ ○ ○ ○○ ○○ ○ ○ ○ ○ ○○○○○○○○ ○ ○ ○○ ○○ ○ ○ ○ ○ ○○○○ ○○○○ ○ ○ ○ ○ ○○ ○○ ○○ ○○ ○ ○ ○ ○ ○ ○ ○ ○ ○○○○○○○○○○○○○○○○ to read the rows diagonally to straighten(ish) the triangle. I didn't need to do this, as рандомра указывает. Я мог бы просто повернуть вспять ⍣⎕ the lot to get the same result. Even better, I could have just used ○ чтобы полностью сохранить обратный шаг.

Ну что ж, живи и учись. :-)

Питон (42)

Изначально я хотел опубликовать несколько предложений по решение для стендби (который на самом деле использует правило 18 :), но у меня не было достаточно репутации, чтобы комментировать, поэтому я превратил это в другой ответ. Поскольку он изменил свой подход, я добавил некоторые объяснения.

1. Мои предложения были бы следующими:
2. используйте '%d'*64%tuple(x) вместо ''.join(map(str,x)

сдвиг в нулях вместо переноса списка

что привело бы к следующему коду (93 символа):

Но я оптимизировал дальше, сначала используя longint вместо целочисленного массива и просто распечатав двоичное представление (75 символов):

И, наконец, распечатав восьмеричное представление, которое уже поддерживается интерполяцией printf (42 символа):

Все они будут печатать:

Конечно, есть и графическое решение (131 символ):

Хаскелл (291)

Я не очень хорошо разбираюсь в кодах Haskell. /\ is:

Выход

QBasic 151 символ

8086 Машинный код – 30 байт. ПРИМЕЧАНИЕ. Этоне мой код и не должен приниматься в качестве ответа . Я нашел это, работая над другой компьютерной задачей.для эмуляции процессора 8086 . Включенные текстовые файлы.Дэвид Стаффорд

, но это лучшее, что я мог придумать.

Я публикую это, потому что это умно и коротко, и я подумал, что вы захотите это увидеть.

Он использует перекрывающиеся коды операций для размещения большего количества инструкций в меньшем пространстве. Удивительно умный. Вот машинный код:

Прямое декодирование выглядит так:

При запуске, когда происходит переход на 0x0115, обратите внимание, что он возвращается к 0x010C, прямо в середину предыдущей инструкции:

Великолепно! Надеюсь, вы, ребята, не против, чтобы я поделился этим. Я знаю, что это не ответ сам по себе, но это представляет интерес для решения задачи.

АПЛ (51)

• 2|!/~i.32 : A is a vector of 67 zeroes
• [2 0 0 2 7 4]concat : the 34th element is 1
• -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 : starting with A, do:
• X: add al,0x13 int 0x10 and cl,ch mov ah,0x0C loop X : if the first element of the current row is zero
• 04 13 CD 10 20 E9 B4 0C E2 F6 : add the current row to the answer, and recurse with:
• # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # : the vector where each element is the XOR of its neighbours in the previous generation
• 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 } : otherwise, we're done
• 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(""));} : format this in a 67x32 matrix
• !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !! !! !! !! !! !! !! ! ! ! ! ! ! ! ! ! !! !!!! !!!! !!!! ! ! ! ! ! ! ! ! ! !! !! !! ! ! ! ! ! !!!!!! !!!!!!!! ! ! ! ! ! ! ! ! ! !! !! !! ! ! ! ! ! !! !!!! ! ! ! ! ! !! ! ! ! !!!!!!!!!!!!!! ! ! ! ! ! ! ! ! ! !! !! !! ! ! ! ! ! !! !!!! ! ! ! ! ! !! ! ! ! !!!!!! ! ! ! ! ! !! ! ! ! !! ! ! ! ! ! : add one to select the right value from the character array
• ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! "" "" "" "" "" "" "" "" "# !"# !"# !"# !"# !"# !"# !"# $$$$ $$$$ $$$$ $$$$ !$%$% ! !$%$% ! !$%$% ! !$%$% ""$$&& ""$$&& ""$$&& ""$$&& "#$%&' !"#$%&' !"#$%&' !"#$%&' (((((((( (((((((( ! ! !()()()() ! ! ! !()()()() "" ""((**((** "" ""((**((** "# !"#()*+()*+ !"# !"#()*+()*+ $$$$((((,,,, $$$$((((,,,, !$%$%()(),-,- ! !$%$%()(),-,- ""$$&&((**,,.. ""$$&&((**,,.. "#$%&'()*+,-./ !"#$%&'()*+,-./ 0000000000000000 ! ! ! ! ! ! !0101010101010101 "" "" "" ""0022002200220022 "# !"# !"# !"#0123012301230123 $$$$ $$$$0000444400004444 !$%$% ! !$%$01454501014545 ""$$&& ""$$&&0022446600224466 "#$%&' !"#$%&'0123456701234567 ((((((((0000000088888888 ! ! !()()()()0101010189898989 "" ""((**((**0022002288::88:: "# !"#()*+()*+0123012389:;89:; $$$$((((,,,,000044448888<<<< !$%$%()(),-,-010145458989<=<= ""$$&&((**,,..0022446688::<<>> "#$%&'()*+,-./0123456789:;<=>? ... ++i<=a Объяснение:

: вывести либо пробел (не часть треугольника), либо круг (если он является частью треугольника)

Выход:

С 127 119 116 108 65 (32|!(i&j)) getting it to print pretty output would take 1 more char (you can get really ugly output by sacrificing the (32^i&j) ).

Здесь используется трюк HTML-ответа a^ to ^ i & j Чтобы сделать это красиво ] to ' ○'[ и выключи его из

. Однако тратить символы на внешний вид мне кажется неправильным.

Ужасный вывод:

Мне вообще-то нравится, как это выглядит. Но если вы настаиваете на том, чтобы это было красиво, вы можете закрепить четыре символа. Красивый вывод:

Оставляем старую версию клеточного автомата, состоящую из 108 символов.

Так что я не думаю, что мне удастся сделать это намного короче, поэтому я объясню код. Я оставлю это объяснение, так как некоторые трюки могут оказаться полезными.

Некоторые результаты

Код 80x86/MsDos — 10 байт

Как сайзкодер, специализирующийся на очень маленьких вступлениях в MsDos, мне удалось придумать программу, которая занимает всего 10 байт.

в шестнадцатеричном формате:

в ассемблере:

Первой версией, которую я написал, была «Colpinski», размер которой составлял 16 байт, и она даже была интерактивной, так что вы могли менять цвет с помощью клавиатуры и мыши. Вместе с «Frag» — еще одним кодировщиком размера — мы сократили его размер до 13 байт, что позволило создать 10-байтовую программу, содержащую только основную процедуру. Когда все анимировано, становится немного интереснее, поэтому я упомяну еще одну версию. Зомпинского 64

- пытаюсь имитировать точное поведение "Zoompinski C64" размером 512 байт - также для MsDos, размером 64 байта, как следует из названия.

Скачать оригинал и прокомментировать "Пуэт"

PostScript, 120 символов.

Вывод Ghostscript:

Это рисование фигуры путем рекурсивного утроения уже нарисованного.

Первый шаг — рисование линии. Строка сохраняется как путь пользователя, затем путь пользователя добавляется еще два раза после каждого поворота на 120 градусов. A←67⍴0 moves the "rotation point" to the center of the next big white "center triangle" that is to be enclosed by replications of the triangle we already have. Here, we're back to step 1 (creating a upath that's tripled by rotation).

Количество итераций контролируется первым числом в строке 3.

Дж (9 символов)

Это, пожалуй, самое уродливое, вам действительно нужно прищуриться, чтобы увидеть результат;)

производит вывод

конечно, вы можете отобразить это графически:

АПЛ, 37 32 (28 23)

Вертикальный треугольник (37 32 символа)

Объяснение

• 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 : Create a 1×2 character matrix /\ /__\ /\ /\ /__\/__\ /\ /\ /__\ /__\ /\ /\ /\ /\ /__\/__\/__\/__\ /\ /\ /__\ /__\ /\ /\ /\ /\ /__\/__\ /__\/__\ /\ /\ /\ /\ /__\ /__\ /__\ /__\ /\ /\ /\ /\ /\ /\ /\ /\ /__\/__\/__\/__\/__\/__\/__\/__\
• solve 4 : A function that pad the right argument on both sides with blanks to create a matrix double as wide, then laminates the right argument itself doubled onto the bottom.
  Например. 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 would become

• 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 : Recur the function (user input) times.

Пример вывода

Перекошенный треугольник (28 23 символа)

Объяснение

• 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 : Create a 1×1 character matrix (,,.~)^:6,'o'
• |. : A function that pad the right argument on the right with blanks to create a matrix double as wide, then laminates the right argument itself doubled onto the bottom.
  Например. ,/. would become

• oooo o o oo o : Recur the function (user input) times.

Пример вывода

матлаб 56

Питон (75)

Я опоздал на вечеринку на два года, но удивлен, что никто до сих пор не применил такой подход.

Использует Продукт Кронекера заменить матрицу несколькими ее копиями.

Я мог бы сэкономить два символа, используя oo in line three to get a 16x16 pixel image with three visible levels or add another char to the iterator and end up with a 2^16 x 2^16 = 4.3 Gigapixel image and 15 triangle levels.

Логотип, 75 символов

59 символов только для первой функции, вторая вызывает первую с размером и глубиной/количеством итераций. Таким образом, вы можете просто вызвать первую функцию из интерпретатора с помощью команды: e 99 5 или любого размера, который вы хотите вывести.

Дж (18 символов)

Результат

Питон (90 символов)

Попробуйте онлайн

Нарисуйте фрактальную линию, заполняющую треугольник Серпинского.

АПЛ (Диалог Классик), 12 байт

Попробуйте онлайн!

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

Тетраэдр Серпинского можно нарисовать аналогичным образом:

Дж, ³⁷ 35 байт

-2 байта благодаря FrownyFrog

Попробуйте онлайн!

Это ascii-версия Питера Тейлора, преобразованная в J. Можно было бы сэкономить байты с помощью менее красивой версии, но почему?

Луа сценарий в Боже мой, 54 байта

Golly — это симулятор клеточных автоматов с поддержкой сценариев Lua и Python.

Этот сценарий устанавливает правило Wolfram Rule 60, устанавливает для ячейки (0,0) значение 1 и выполняет 512 шагов.

05AB1E, 9 байт

Попробуйте онлайн!

Количество строк равно входному.

Объяснение:

При этом используется тот факт, что a(n+1) = a(n) XOR 2*a(n), который я нашел на эта соответствующая страница OEIS

Математика 63

Математика 67

С, 106 символов

(Меня это до сих пор забавляет <canvas> is the shortest way to output a newline in C.)

Обратите внимание, что вы можете создать прокладки большего (или меньшего) размера, заменив 8 in the 64 тест цикла с большей (меньшей) степенью двойки, если вы также замените k in the middle of the canvas со степенью два плюс один.

Постскриптум, 205 203

Перепишите с использованием строк, и рекурсия закончится точно таким же счетчиком. Однако глубинные ограничения макроподхода преодолеваются.

Редактировать: <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> is shorter than x-~y/2,k-y .

Сделал отступы и прокомментировал.

Добавление x & y == 0 gives a better impression of how deep this one goes.

6502 АСМ, 134 байта

Довольно просто. Отображает треугольники. Обратите внимание, что верхняя и левая части изображения невидимы из-за белого фона PPCG.