23

Кто не любит хороший фрактал? Серпинского Ковер является классическим примером фрактала.

Для выполнения этой задачи вам потребуется сгенерировать ковер типа $n$ и распечатать получившееся изображение в stdout(форматирование см. Ниже) $n$ , представляющем ковер уровня. Шаги можно найти в этой статье Википедии .

Это значение будет взято stdinили эквивалентно.

Например, при вводе 4 будет получен ковер 4-го уровня:

■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■
■   ■       ■   ■ ■   ■       ■   ■ ■   ■       ■   ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■                   ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■                   ■ ■ ■       ■ ■ ■
■   ■       ■   ■                   ■   ■       ■   ■
■ ■ ■       ■ ■ ■                   ■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■                   ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■
■   ■       ■   ■ ■   ■       ■   ■ ■   ■       ■   ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■

Ввод 3 даст ковер 3 уровня:

■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■
■   ■       ■   ■
■ ■ ■       ■ ■ ■
■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■

Ввод 2 даст ковер 2 уровня:

■ ■ ■
■   ■ 
■ ■ ■

И ввод 1 даст ковер 1-го уровня (просто квадрат):

■

Обратите внимание на пробелы между столбцами.

Идея состоит в том, чтобы использовать символ ■ для блоков и пробел для пробелов

Строка начинается с символа ■.

Как всегда, наименьшее решение выигрывает по количеству символов (из-за нестандартных символов).

Кроме того, # можно использовать вместо символа ■ в языках, которые не поддерживают Unicode.

code-golf ascii-art fractal

— Пол Клавье
источник

1

Разве первый пример не является третьим уровнем, а не вторым?

— Оптимизатор

6

Хороший вопрос, но они должны быть этими персонажами? это не ASCII, что исключает множество языков. Могут ли они быть просто пространством и X или O? Я действительно думаю, что ваше изображение будет выглядеть лучше с пробелами, а не с пустыми квадратами.

— Уровень Река St

Поменял губку на ковры, спасибо.

— Пол Клавье

Что если ваш язык не поддерживает вывод Unicode, есть ли альтернатива ASCII?

— flawr

1

Могут ли строки иметь конечные пробелы?

— Деннис

15

CJam, 38 37 31 30 28 знаков

Ну что ж, мы считаем по символам, поэтому давайте распакуем Unicode:

"B胷맋풽巓뱖ᮨ㣙¬䙧੥墱륋청"2G#b129b:c~

Проверьте это здесь. Просто введите желаемый уровень в поле ввода.

объяснение

После преобразования базы это

3li(#,{3b1f&2b}%_f{f{&S9632c?S}N}

что аналогично следующему, только с символом Unicode, записанным как 9632c:

3li(#,{3b1f&2b}%_f{f{&S'■?S}N}

Этот код основан на следующем наблюдении: если мы посмотрим на координаты (x, y) каждой ячейки, то получим пустую ячейку, когда и x, и y имеют 1одинаковое положение в своем представлении base-3. Если подумать, то мелкомасштабный повторяющийся шаблон - это значащая цифра основания-3, затем следующая более значимая цифра управляет следующим крупномасштабным повторением и так далее.

3                                      "Push a 3 on the stack.";
 li(                                   "Read input, convert to integer, decrement.";
    #                                  "Raise to that power. This yields the dimensions.";
     ,                                 "Turn into a range array.";
      {       }%                       "Map the block onto the array.";
       3b                              "Convert to base 3.";
         1f&                           "Bit-wise AND each digit with 1.";
            2b                         "Convert to base 2.";
                _                      "Duplicate this list.";
                 f{          }         "Map this block onto one list, with the second list
                                        as an additional parameter.";
                   f{      }           "Map this block onto the second list, with the first
                                        list's current element as an additional parameter.";
                                       "I.e. this iterates over all coordinate pairs.";
                     &                 "Bitwise AND to check that the base-3 representations
                                        had a 1 in the same position.";
                      S'■?             "Select the right character.";
                          S            "Push a space.";
                            N          "Push a newline";

Содержимое полученного массива печатается автоматически.

Спасибо Деннису за то, что он сбрил три байта.

— Мартин Эндер
источник

2

#0<'■S-> #~S'■сохраняет 1 символ.

— Оптимизатор

Вы можете заменить [1_]a#~на 3Yba&.

— Деннис

@ Денис аккуратный. Спасибо!

— Мартин Эндер

@ Денис Я постоянно забываю, что &производит истинное / ложное значение (или даже то, что оно существует). Может быть, стоит написать в советах CJam канонический способ проверить, содержит ли массив какой-либо элемент.

— Мартин Эндер

1

@Ypnypn Нет. Это выглядит длиннее, но это потому, что символы Unicode не моноширинные. Распакованный код состоит из 30 символов.

— Мартин Эндер

7

Матлаб (113) (110) (99) (85)

Вы можете попробовать это здесь (Вам придется заменить input('')на желаемый вход.)

Теперь 99 благодаря feersum! А теперь до 85 благодаря RTL!

Golfed:

a=ones(3);a(5)=0;c=1;for i=2:input('');c=kron(c,a);end;disp(char(kron(c,[1,0])*3+32))

Ungolfed:

a=ones(3);a(5)=0;c=1;  %creating the template / anchor
for i=2:input('');
    c=kron(c,a);       %recursive iterations
end;
disp(char(kron(c,[1,0])*3+32))

~~d=[c,c]*0; %this is all just for adding the additional spaces d(:,1:2:end)=c; disp(char(d*3+32)); %converting to spaces (32) and # (35)~~

Объяснение:

Я злоупотребляю продуктом kronecker для этой задачи. (Это специальный продукт, определенный для двух матриц произвольного размера. Пример:

A = [1,2] is a 3x2 matrix, B is a nxm matrix.
    [3,4]
    [5,6]

затем

kron(A,B) = [1*B , 2*B] is a 2n x 2m matrix.
            [3*B , 4*B]
            [5*B , 6*B]

Вот пример для n = 5 (в старом методе подсчета это 4);

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

— flawr
источник

Спасибо, я не заметил, что требования изменились. Я также обновил код (мне просто нужно было изменить начальное значение цикла for.)

— flawr

Вместо d=zeros(size([c,c]))вас следует использовать d=[c c]*0.

— feersum

красиво, предложение: переменная dможно избежать путем злоупотребления kronеще раз: disp(char(kron(c,[1,0])*3+32));,

— RTL

6

Хаскелл, 114 108

s 1=["# "]
s n=k j++k(map(>>" ")j)++k j where j=s$n-1;k i=j%i%j
(%)=zipWith(++)
main=interact$unlines.s.read

— гордый хаскеллер
источник

5

Питон - 100

r=range(3**~-input())
for i in r:print" ".join("# "[any(i/3**k%3==j/3**k%3==1for k in r)]for j in r)

— Wrzlprmft
источник

5

Perl 5: 68 символов

п на стандартный.

#!/usr/bin/perl -l
//,print map/2/?"  ":"■ ",map$_+$',@,for@,=grep!/[24-9]/,0..3x<>/10

Десятичное закодированное троичное представление списка координат сначала генерируется в @,(имя выбрано таким образом, что между @,и и нет необходимости в пробелах for), используя цифры 0, 1 и 3. Теперь при добавлении координат x и y в десятичной области получим 2 в результате, если и только если было два в совпадающих позициях. //используется для распространения переменной по умолчанию $_из внешнего цикла ( for) в переменную postmatch, $'когда она скрыта переменной по умолчанию mapво внутреннем цикле.

— nutki
источник

4

Java, 330 283 персонажа

class T{public static void main(String[]a){int n=Integer.valueOf(a[0]);int m=(int)Math.pow(3,n-1);for(n=0;n<m;n++){for(int j=0;j<m;){String s="#";int x=n;int y=j++;while(x>0||y>0){if(x%3==1&&y%3==1){s=" ";}x/=3;y/=3;}p(s);}p("\n");}}static void p(String s){System.out.print(""+s);}}

Param - это размер, который вы хотите. Если не было оптимизации для алгоритма, я пытался подавить все.

Благодаря @StretchManiac, удаляющему iметод и очищающему декларации, пришлось потрудиться .

Читаемый код

class T {
    public static void main(String[] a) {
        int n = Integer.valueOf(a[0]);
        int m = (int) Math.pow(3, n - 1);
        for (n = 0; n < m; n++) {
            for (int j = 0; j < m;) {
                String s = "#";
                int x = n;
                int y = j++;
                while (x > 0 || y > 0) {
                    if (x % 3 == 1 && y % 3 == 1) {
                        s = " ";
                    }
                    x /= 3;
                    y /= 3;
                }
                p(s);
            }
            p("\n");
        }
    }

    static void p(String s) {
        System.out.print("" + s);
    }
}

— Компас
источник

Вы можете избавиться от «public» перед классом, как основной аргумент, который вы можете сделать String[]a, и если вы используете только iодин раз, то вам лучше избавиться от метода.

— Растянуть маньяка

@StretchManiac спасибо за советы. Я реализую их немного позже.

— Компас

3

Почему, черт возьми, вы делаете ""+sв своем pметоде? Это три лишних символа, абсолютно бесполезных. Даже если бы они sбыли чем- Stringто еще, это все равно было бы совершенно ненужным.

— Дэвид Конрад

1

Измените это на static void p(int s){System.out.print((char)s);}и в основном сделайте это int s=35;, s=32;и p(10);(вместо p("\n");) и сохраните еще несколько символов.

— Дэвид Конрад

Вы можете сохранить семь символов, изменив Integer.valueOfнаnew Byte

— Ypnypn

4

Ракетка 230 229 225 220

Не лучший час ракетки для игры в гольф.

Golfed:

(define(s n)(letrec([t(λ(x y)(if(or(= x 0)(= y 0))"■"(if(=(modulo x 3)(modulo y 3)1)" "(t(floor(/ x 3))(floor(/ y 3))))))][i(expt 3(- n 1))])(for-each displayln(for/list([r i])(string-join(for/list([c i])(t r c))" ")))))

Ungolfed:

(define (s n)
  (letrec ([t (λ (x y)
                (if (or (= x 0) (= y 0)) 
                    "■"
                    (if (= (modulo x 3) (modulo y 3) 1)
                        " "
                        (t (floor (/ x 3)) (floor (/ y 3))))))]
           [i (expt 3 (- n 1))])
    (for-each displayln 
              (for/list ([r i])
                (string-join 
                 (for/list ([c i]) 
                   (t r c)) " ")))))

— Мэтью Баттерлик
источник

4

C: 123 118 111 104 символов

Основано на аналогичной идее моего решения на Perl. После добавления пробелов:

m=0x55555555;
x;
main(n){
  scanf("%d",&n);
  n=1<<2*--n;
  for(x=n*n;x--;)
    printf(x&x/2&m?"":"%c%c",x&x/n&m?32:35,x&n-1?32:10);
}

Использует троичную систему кодирования каждой цифры с 2 битами. Недопустимые значения (имеющие два в нечетно-четном положении) фильтруются с помощью x & (x>>1) & 0b01010101. Обе координаты хранятся в одном значении, поэтому проверка цвета пикселя сводится к x & (x >> 2 * n) & 0b01010101. nдля удобства хранится как степень 2.

редактировать

Заменено defineна простую константу m.

Редактировать 2

0x5555555маска может быть представлена с помощью (1LL<<32)/3, но нам нужны только nэти биты, поэтому n/3достаточно.

x;
main(n){
  scanf("%d",&n);
  n=1<<2*--n;
  for(x=n*n;x--;)
    printf(x&x/2&n*n/3?"":"%c%c",x&x/n&n/3?32:35,x&n-1?32:10);
}

Редактировать 3

Незначительные изменения Одно усиление в 2 символа, зависящее от выполнения scanf перед загрузкой значения nдля выполнения --n. Эол может только следовать #, дух.

x;
main(n){
  n=scanf("%d",&n)<<2*--n;
  for(x=n*n;x--;)
    x&x/2&n*n/3||printf(x&x/n&n/3?"  ":x&n-1?"# ":"#\n");
}

— nutki
источник

3

HTML / JavaScript, 205 символов

Обфускатвит , 205 символов

document.write(unescape(escape('🁳𨱲𪑰𭀾𬰽𙰦𫡢𬱰𞰧𞱮🐴𞱭👍𨑴𪀮𬁯𭰨𜰬𫠭𜐩𞱦𫱲𚁩🐰𞱩🁭𞱩𚰫𛁤𚀧🁢𬠾𙰩𚑻𩡯𬠨𪠽𜀻𪠼𫐻𚑩𩠨𨰨𪐬𪠫𚰩𚑤𚀧𘰧𚐻𩑬𬱥𘁤𚁳𚑽𩡵𫡣𭁩𫱮𘁣𚁸𛁹𚑻𭱨𪑬𩐨𮁼𯁹𚑻𪑦𚁸𙐳🐽𜐦𙡹𙐳🐽𜐩𬡥𭁵𬡮𘀰𞱸👦𚁸𚐻𮐽𩠨𮐩𯑲𩑴𭑲𫠠𜑽𩡵𫡣𭁩𫱮𘁦𚁡𚑻𬡥𭁵𬡮𘁍𨑴𪀮𩡬𫱯𬠨𨐯𜰩𯑦𭑮𨱴𪑯𫠠𩀨𨐩𮱤𫱣𭑭𩑮𭀮𭱲𪑴𩐨𬰫𨐩𯐼𛱳𨱲𪑰𭀾🁳𭁹𫁥🠪𮱦𫱮𭀭𩡡𫑩𫁹𞠢𠱯𭑲𪑥𬠢').replace(/uD./g,'')))

HTML / JS, 298 символов

Из-за того, как HTML играет с пробелами, несколько символов должны были быть выделены для символа nbsp. Кроме того, шрифтом по умолчанию в большинстве браузеров является не Courier, поэтому мне пришлось установить его тоже. Около 20 символов стоит стиля. Если для этого требуется метод прямого ввода, я могу добавить его, но при изменении ввода в настоящий момент задается другое значение n.

демонстрация

<script>s='&nbsp;';n=4;m=Math.pow(3,n-1);for(i=0;i<m;i++,d('<br>')){for(j=0;j<m;)if(c(i,j++))d('#');else d(s)}function c(x,y){while(x||y){if(x%3==1&&y%3==1)return 0;x=f(x);y=f(y)}return 1}function f(a){return Math.floor(a/3)}function d(a){document.write(s+a)}</script><style>*{font-family:"Courier"

Читаемый HTML / JS

<script>
    s='&nbsp;';
    n=4;
    m=Math.pow(3,n-1);
    for(i=0;i<m;i++,d('<br>')){
        for(j=0;j<m;)
            if(c(i,j++))
                d('#');
            else d(s)
    }
    function c(x,y){
        while(x||y){
            if(x%3==1&&y%3==1)
                return 0;
            x=f(x);
            y=f(y)
        }
        return 1
    }
    function f(a){
        return Math.floor(a/3)
    }
    function d(a){
        document.write(s+a)
        }
</script>
<style>
*{font-family:"Courier"

— Компас
источник

3

CJam, 38 35 32 31 символов

"■ ""՛ୗ䁎뽔휼ꆩ闳⾿➺⥧槲㩡郊"6e4b128b:c~

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

Пример запуска

$ cjam <(echo '"■ ""՛ୗ䁎뽔휼ꆩ闳⾿➺⥧槲㩡郊"6e4b128b:c~') <<< 3; echo
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■ ■       ■ ■ ■ 
■   ■       ■   ■ 
■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■

Как это работает

"՛ୗ䁎뽔휼ꆩ闳⾿➺⥧槲㩡郊"6e4b128b:c~

преобразует строку Unicode из base 60,000 ( 6e4b) в base 128 ( 128b), преобразуется в Character ( :c) и оценивает результирующую строку ( ~).

В результате выполняется следующий код:

"■ "                                " C := '■ '                                           ";
    li(                             " J := int(input()) - 1                               ";
       {                      }*    " for I in range(J):                                  ";
        z]A*                        "   T := [zip(C)] * 10                                ";
            ):,                     "   U := pop(T)                                       ";
               Sf*                  "   V := [ ' ' * len(u) : u ∊ U ]                     ";
                  4\t               "   U[4] := V                                         ";
                     3/{:+z~}%      "   C := { c : c ∊ zip(concat(u)), u ∊ U.split(3) }   ";
                              zN*  " print '\n'.join(zip(C))                              ";

— Деннис
источник

3

Python 3 - 116 113 персонажей

РЕДАКТИРОВАТЬ: Ну, использовал трюк, я сам не очень люблю и сжал код на 3 байта. Не знаю, если это самый лучший способ, но я пойду с этим.

exec(bytes('ⱴ㵬❛離₠崧氬浡摢⁡㩺癥污稨✫⁫潦⁲⁫湩琠❝਩潦⁲⁩湩爠湡敧椨瑮椨灮瑵⤨⴩⤱爺瀬氽✨㍛✪Ⱙ⡬嬢⭫‧✠⠪⨳椪⬩⤢琻爽瀫爫昊牯椠椠⁮㩴牰湩⡴⥩','utf-16')[2:].decode('utf-8'))

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

'ⱴ㵬❛離₠崧氬浡摢\u2061㩺癥污稨✫\u206b潦\u2072\u206b湩琠❝\u0a29潦\u2072\u2069湩爠湡敧椨瑮椨灮瑵⤨\u2d29⤱爺瀬氽✨㍛✪Ⱙ⡬嬢\u2b6b‧✠⠪⨳椪⬩⤢琻爽瀫爫昊牯椠椠\u206e㩴牰湩⡴⥩'

Не слишком хорошо, но, по крайней мере, лучше, чем некоторые языки.

На что это распространяется:

t=['■ ']
for i in range(int(input())-1):r,p=[k*3for k in t],[k+'  '*(3**i)+k for k in t];t=r+p+r
for i in t:print(i)

Немного безрассудно, если кто-то не видит, как это работает:

t=['■ ']                                     # iteration 1
for i in range(int(input()) - 1):            # do n-1 more iterations
    r = [k * 3 for k in t]                   # first & last rows are the last carpet x3
    p = [k + '  ' * (3 ** i) + k for k in t] # middle row: last carpet, space, last carpet
    t = r + p + r                            # and put them to the new carpet
for i in t:                                  # print final iteration
    print(i)

— PurkkaKoodari
источник

Вау, Питон, это впечатляет

— Пол Клавье

3

Mathematica, 71 байт

Grid@Nest[ArrayFlatten@ArrayPad[{{0}},1,{{#}}]&,1,#]/.{0->"",1->"■"}&

вход

3

выход

— J42161217
источник

Я следовал за тобой, как полный лианы. +1;).

— Волшебная Урна Осьминога

Как вы думаете, вы можете сократить это с SubstitutionSystem ?

— Виталий Кауров

2

CJam, 76 символов

3ri(#:M_*,{_M/:I\M%:J;;{I3%1=J3%1=&0X?:X;I3/:I0>J3/:J0>|}gX'■S?1:X;}%M/Sf*N*

Это прямой перевод приведенной здесь формулы

Попробуй здесь

— оптимизатор
источник

2

Bash + coreutils, 105 символов юникода

Поскольку мы считаем символы, а не байты:

eval `iconv -tunicode<<<潦⡲眨㌽⨪␨ⴱ⤱琬〽琻眼眪琻⬫⤩笻戠ꂖ昻牯⠨㵸╴ⱷ㵹⽴㭷㹸簰祼〾砻㴯ⰳ⽹㌽⤩笻⠠砨㌥ㄭ籼╹ⴳ⤱簩扼尽簠硼〽紻瀻楲瑮⁦␢⁢㬢⠨╴⵷⭷⤱簩敼档㭯੽|cut -b3-`

В расшифрованном виде:

Чистый Баш, 143 байта

for((w=3**($1-1),t=0;t<w*w;t++));{
b=■
for((x=t%w,y=t/w;x>0||y>0;x/=3,y/=3));{
((x%3-1||y%3-1))||b=\ ||x=0
}
printf "$b "
((t%w-w+1))||echo
}

Ввод взят из аргументов командной строки:

Выход:

$ ./sierpinskicarpet.sh 3
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■ ■       ■ ■ ■ 
■   ■       ■   ■ 
■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
$

— Цифровая травма
источник

2

C #

Полная программа - 237:

using System;class P{static void Main(string[] a){int b=(int)Math.Pow(3,int.Parse(a[0])-1),c,d,e,f;for(c=0;c<b;c++){var g="";for(d=0;d<b;){var h="■";e=c;f=d++;while(e>0|f>0){h=e%3==1&f%3==1?" ":h;e/=3;f/=3;}g+=h;}Console.WriteLine(g);}}}

LINQPad - 166 + Math.Ceiling(Math.Log(a + 1) / Math.Log(10))

int a=3;int b=(int)Math.Pow(3,a-1),c,d,e,f;for(c=0;c<b;c++){var g="";for(d=0;d<b;){var h="■";e=c;f=d++;while(e>0|f>0){h=e%3==1&f%3==1?" ":h;e/=3;f/=3;}g+=h;}g.Dump();}

— Уильям Барбоза
источник

Я знаю, что прошло почти три года, но вы можете играть в гольф несколько вещей, как это:

using System;class P{static void Main(string[]a){string g,h;for(int b=(int)Math.Pow(3,int.Parse(a[0])-1),c=-1,d,e,f;++c<b;Console.WriteLine(g))for(g="",d=0;d<b;g+=h)for(h="■",e=c,f=d++;e>0|f>0;e/=3,f/=3)h=e%3==1&f%3==1?" ":h;}}

( 229 байтов / 227 символов ) ( ■= 3 байта, так что вы можете заменить его, #чтобы сэкономить 2 байта). В основном я поместил все внутри петли for, так что больше нет необходимости в скобках.

— Кевин Круйссен,

2

С - 154

Ввод от стандартного ввода. Я пытался найти хороший способ избежать дополнительной функции, но не смог придумать какую-либо.

Количество символов включает только необходимые пробелы.

p(l,x,y){
    return l?x/l&y/l&1||p(l/3,x%l,y%l):0;
}
x,y;
main(v){
    scanf("%d",&v);
    v=pow(3,--v);
    for(;y<v;y++,puts(""))
        for(x=0;x<v;)
            printf("%c ",p(v,x++,y)?32:35);
}

— Allbeert
источник

1

PHP, 194 символа

nПолучил в качестве первого аргумента в командной строке.

<?php
function d(&$a,$n,$e,$x,$y){if(--$n)for(;$i<9;)$p=pow(3,$n)|d($a,$n,$e|$i==4,$x+$p*$j,$y+$p*($i-$j)/3)|$j=++$i%3;else$a[$x][$y]=$e?" ":■;}@d($a,$argv[1]);foreach($a as$s)echo join($s),"
";

Удобочитаемый

<?php

function draw(&$array, $n, $empty, $x, $y) {
    $n--;
    if ($n != 0) {
        for ($i = 0; $i < 9; $i++) {
            $j = $i % 3;
            $p = pow(3, $n);
            draw($array, $n, $empty || $i == 4, $x + $p * $j, $y + $p * ($i - $j) / 3);
        }
    } else {
        $array[$x][$y] = $empty ? " " : "#";
    }
}

$array = array();
draw($array, $argv[1], false, 0, 0);
foreach ($array as $line) {
    echo join($line), "\n";
}

— Gedrox
источник

1

Если вы используете символ ■вместо #, вы можете сохранить 2 символа, удалив кавычки.

— Исмаэль Мигель

1

Scala 230 персонажей

Гольф-код:

object T extends App {def m=math.pow(3,args(0).toInt-1).toInt-1;def p=print _;val x=0 to m;x.map{n=>x.map{j=>if(q(n,j)==1)p(" #");else p("  ")};p("\n");};def q(n:Int,j:Int):Int={if(n>0|j>0)if((n%3&j%3)==1)0 else q(n/3,j/3)else 1}}

Ungolfed код:

object T extends App {
  def m = math.pow(3, args(0).toInt - 1).toInt - 1;

  def p = print _;
  val x = 0 to m;
  x.map { n => x.map { j => if (q(n, j) == 1) p(" #"); else p("  ")}; p("\n");};

  def q(n: Int, j: Int): Int = {
    if (n > 0 | j > 0) if ((n % 3 & j % 3) == 1) 0 else q(n / 3, j / 3) else 1
  }
}

Только необходимые пробелы включены.

— Mathill
источник

1

V , 21 байт (не конкурирующий)

é*Àñ}yPgvr PGï3pyGHP

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

HexDump:

00000000: e92a c0f1 167d 7950 6776 7220 5047 ef33  .*...}yPgvr PG.3
00000010: 7079 4748 50                             pyGHP

V новее, чем вызов, поэтому он должен быть помечен как не конкурирующий. Но все - таки, это приятно видеть , что этот ответ является waaaaay короче , чем все остальные, даже при подсчете в байтах , а не символы.

— DJMcMayhem
источник

Просто напоминание; это больше не является конкурирующим

— RedClover

1

ок, 40 байт

`0:" #"{(x-1)(,'//3 3#111101111b*9#,)/1}

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

Он начинается с 1, а затем рисует его в сетке (1 1 1;1 0 1;1 1 1), которую он затем рисует в сетке таким же образом и т. Д., Повторяется необходимое количество раз.

— zgrep
источник

1

Python 2 , 91 байт

r=input()-1
for i in range(3**r):x,s='# ','  ';exec"x+=[x,s][i%3%2]+x;s*=3;i/=3;"*r;print x

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

— XNOR
источник

1

C # (.NET Core) , 162 байта

n=>{var f="";int s=(int)Math.Pow(3,n),z=0;while(z<s*s){int x=z%s,y=z/s,h=1;for(;x>0|y>0;y/=3,x/=3)if(y%3==1&x%3==1)h=0;f+=" #"[h]+(z++%s<s-1?" ":"\n");}return f;}

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

Degolfed

n=>{
    var f="";
    int s=(int)Math.Pow(3,n),z=0;

    while(z<s*s)
    {
        int x=z%s, y=z/s, h=1;
        for(; x>0 | y>0; y/=3, x/=3)
            if(y%3==1 & x%3==1)
                h=0;

        f += " #"[h] + (z++%s<s-1? " " : "\n");
    }

    return f;
}

— Ayb4btu
источник

0

SOGL V0.12 , 27 байт

 ■¹.H{³³┼┼≥: ■@ŗ;┼┼⁴++}{@∑P

Попробуй здесь!

— dzaima
источник

0

R , 92 символа

94 байта со специальным символом.

write(c(" ","■")[1+Reduce("%x%",rep(list(matrix(c(1,1,1,1,0,1),3,3)),n<-scan()-1),1)],1,3^n)

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

— Giuseppe
источник

Я просто поражен, что люди все еще делают это 4 года спустя

— Пол Клавье

1

@PaulClavier это большой вызов; Вы должны гордиться :)

— Джузеппе

0

Холст , 17 16 17 знаков

■；╷［⌐ ＋２×；┌∔∔；３＊＋

Попробуй это здесь!

-1: используется ［вместо того, ｛чтобы удалить первый ；внутри цикла.
+1: исправлено ошибочное поведение: ■теперь соответствует уровню 1, как указано в исходном посте.

— hakr14
источник

Он будет конкурировать, на более новый консенсус.

— Эрик Outgolfer

@EriktheOutgolfer о, спасибо, что сообщили мне знать!

— hakr14

И да, в этом случае счет равен 17, но мы считаем решения в байтах, а не в символах (у Canvas есть кодовая страница).

— Эрик Outgolfer

@EriktheOutgolfer обычно да, но в этом задании используются символы из-за ■многобайтовости. Так говорится в нижней части оригинального поста.

— hakr14

Вам нужно добавить один для всех ваших входов. 1 должен вернуть квадрат (то есть, что 0 возвращает здесь)

— Пол Клавье

0

Пип `-S` , 30 символов

"■■ "@MX{{aTB3R2i}MSg}MC3**a/3

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

Основная идея: рассмотрим координатную сетку в базе 3. Отверстия в ковре возникают там, где 1) трит в координате x 1и 2) трит в той же позиции в y-координате также 1.

"■■ "@MX{{aTB3R2i}MSg}MC3**a/3
                                i is 0; a is 1st cmdline arg (implicit)
                        3**a/3  Width/height of the carpet
                      MC        Make a coordinate grid that size and map this function
                                to the coordinate pairs:
                    g            Take each [x y] pair
                  MS             Map this function to each coord and add the results:
         {aTB3   }                Convert to base 3
              R2i                 Replace 2's with 0's
                                  E.g. 15 -> 120 -> 100 and 16 -> 121 -> 101
                                 When we add the results, we get [15 16] -> 201
      MX{            }           Take the max of that list (0, 1, or 2)
"■■ "@                           Use that to index into this string (resulting in a space
                                 iff two 1's coincided to make a 2, or ■ otherwise)
                                Print the resulting nested list with each sublist on its
                                own line and space-delimited (implicit, -S flag)

Аналогичное решение, такое же количество символов, но -2 байта: {2N({aTB3R2i}MSg)?s'■}MC3**a/3

— DLosc
источник

0

K (нгн / к) , 50 байтов

спасибо @DLosc за напоминание, что я должен выводить пробелы между столбцами

1@"\n"/"# "1_',/'1,''+/''a*/:\:a:+2!!1_(. 0:"")#3;

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

— СПП
источник

@DLosc спасибо, исправил и другие странные требования: stdin / stdout вместо arg / result; один за другим "уровень"

— нгн

Ковры Серпинского

CJam, 38 37 31 30 28 знаков

объяснение

Матлаб (113) (110) (99) (85)

Хаскелл, 114 108

Питон - 100

Perl 5: 68 символов

Java, 330 283 персонажа

Читаемый код

Ракетка 230 229 225 220

C: 123 118 111 104 символов

редактировать

Редактировать 2

Редактировать 3

HTML / JavaScript, 205 символов

Обфускатвит , 205 символов

HTML / JS, 298 символов

Читаемый HTML / JS

CJam, 38 35 32 31 символов

Пример запуска

Как это работает

Python 3 - 116 113 персонажей

Mathematica, 71 байт

CJam, 76 символов

Bash + coreutils, 105 символов юникода

Чистый Баш, 143 байта

Выход:

C #

С - 154

PHP, 194 символа

Удобочитаемый

V , 21 байт (не конкурирующий)

ок, 40 байт

Python 2 , 91 байт

C # (.NET Core) , 162 байта

Degolfed

SOGL V0.12 , 27 байт

R , 92 символа

Холст , 17 16 17 знаков

Пип -S , 30 символов

K (нгн / к) , 50 байтов

Пип `-S` , 30 символов