17

Выход

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

Трейлинг допускается Самое короткое решение побеждает.

hint0

hint1:

спасибо @Tahg за исправление подсказки1

code-golf ascii-art kolmogorov-complexity СПП
источник

8

@ngn выводит только вызовы без какого-либо объяснения того, как формировались данные, обычно хмурится (см. codegolf.stackexchange.com/q/126037 ), потому что первый ответ имеет тенденцию сдавливать «таинственную» часть

Уриэль

16

Лично мне не нравятся подобные вызовы, когда выяснение правила / рецепта является частью задачи. Кроме того, как только человек находит это, все остальные могут просто следовать за этим, так почему бы не опубликовать в первую очередь?

Луис Мендо

11

@ LuisMendo Это интересный аргумент. Код гольф в чистом виде о «краткой реализации известного решения». Загадки в их самой чистой форме о поиске решения - реализация либо не актуальна, либо считается занятой работой. Одним из вариантов было бы опубликовать «трюк» в спойлерах. Таким образом, чистые игроки в гольф могут атаковать эту проблему как задачу игры в гольф, а те, кому нравятся как игры в гольф, так и головоломки, могут избежать поиска и решения обоих.

Иона

5

Я думаю, что «таинственная» часть - это то, что я мог бы увидеть больше. Хотя один из ответов может найти уловку, остальная часть - это все еще обычная задача для игры в гольф ... И это хорошая задача для тех, кто в любом случае стремится найти образец в начале.

полностью человек

3

@ H.PWiz, я не уверен, что + 26 / -7 действительно "хорошо принят". Это больше похоже на «плохо принятый, но сумевший ударить HNQ достаточно быстро, чтобы получить перекос».

Питер Тейлор

11

SOGL V0.12 , 17 16 14 байтов

 #6{³IIč▓┼;I+§

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

При более позднем обновлении č▓может быть удалено 12 байт, что преобразует ToS из массива массивов символов многострочной строки в массив строк [["#","#"],[" ","#"]] -> ["##"," #"], поскольку ┼горизонтальное добавление плохо работает с массивами массивов символов, что Iсоздает, потому что он также используется для вращения массива. В SOGL массив массивов символов должен быть = массив строк, но многие вещи пока не поддерживают это ..

Объяснение:

 #            push "#"
  6{          6 times do
    ³           create 3 total copies of ToS
     II         rotate clockwise twice
       č▓       normalize as explained above
         ┼      append horizontally
          ;     get the 3rd copy ontop
           I    rotate clockwise
            +   append vertically
             §  reverse horizontally

dzaima
источник

1

подожди, как это работает

Конор О'Брайен,

@ ConorO'Brien только что добавил объяснение: p

dzaima

о, хорошо `` `` ``

Конор О'Брайен

22

JavaScript (ES6), 233 217 213 198 182 170 163 122 байта

f=_=>[...Array(64)].map((_,x,a)=>a.map(g=(i=(n=64,x),j)=>(n>>=1)?i&n?j&n?g(j,i):` `:j&n?g(i,~j):g(~i,j):`#`).join``).join`
`
document.write(`<pre>${f()}</pre>`)

Развернуть фрагмент

Изменить: Сохранено 14 18 байт благодаря @Shaggy. Сохранено 3 байта благодаря @ngn. Сохранено еще 12 байтов благодаря совместной работе. Сохранение 41 байта путем кражи наблюдений @ user202729 о том, что четверти используют отражения, а не вращения. Ungolfed:

function f() {
    var s = '';
    for (var i = 0; i < 64; i++) {
        for (var j = 0; j < 64; j++) {
            var x = i, y = j, c = '#'; // Default to #
            // Each non-blank quadrant maps to to the original
            // image by doubling and a reflection. Repeat
            // this six times unless we hit the blank quadrant.
            for (var n = 0; n < 6; n++) {
                if (x >= 32) {
                    if (y >= 32) {
                        // Bottom right quarter is a diagonal reflection
                        var t = x - 32;
                        x = y - 32;
                        y = t;
                    } else {
                        // Bottom left quarter is blank
                        c = ' ';
                        break;
                    }
                } else {
                    if (y >= 32) {
                       // Top right corner is a horizontal reflection
                       y = 63 - y;
                    } else {
                       // Top left corner is a vertical reflection
                       x = 31 - x;
                    }
                }
                x *= 2;
                y *= 2;
            }
            s += c;
        }
        s += '\n';
    }
    return s;
}

Нил
источник

Вам нужно посчитать f=здесь? Хорошо сделано, кстати.

Лохматый

217 байт

Мохнатые

1

Вам не нужно f=подсчитывать байты, но фрагмент кода не работает без него.

1

@Neil Есть ли шанс, что вы могли бы добавить объяснение или версию без шкуры?

Иона

1

@Джона, надеюсь, тебе это поможет.

Нил

11

LOGO, 375 341 297 295 278 + 3 байта

Добавьте 3 байта из-за -pфлага, который по умолчанию включает перспективный режим, поэтому не нужно запускать perspectiveкоманду, в целом экономится 9 байтов.

Использовать FMSLogo в Windows с форматом новой строки Unix (LF) (в FMSLogo возникают проблемы с анализом формата новой строки CR)

to R
rt 90
end
to g :w :l
R fd 2*:l R bk :l up 180
run :w
R run :w
fd 2*:l R bk :l run :w
fd 2*:l up 180
end
to h
pu
ask -1[setxyz 0 0 870]g[g[g[g[g[g[rt 45 fd .7 pd fd 0 pu bk .7 lt 45]1]2]4]8]16]32
repeat 64[sety 64-# repeat 64[setx #-1 type if pixel=[0 0 0]""#["\ ]](pr)]
end

К сожалению, нет "Попробуйте онлайн!" ссылку, потому что я не могу найти какой-либо режим поддержки переводчика онлайн.

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

Разбивка картинки на простые повторяющиеся части:

,

Воспользуйтесь подсказкой выше. Однако, поскольку LOGO не поддерживает отражение, мы можем только смоделировать его, войдя в perspectiveрежим 3D ( ) и повернув черепашку на 180 градусов вокруг оси, параллельной экрану компьютера.

Это определяет вспомогательную функцию g, которая дает 2 параметра l(длина стороны изображения) и w(процедура, используемая для рисования изображения), рисует 3 копии своего отраженного изображения. (см. подсказку в вопросе) Процедуру hвыполняют основную процедуру.

user202729
источник

Вы можете пропустить некоторые пробелы, такие как 90 fd-> 90fdи сохранить несколько байтов.

Джонатан Фрех

@JonathanFrech К сожалению, FMSLogo не поддерживает это.

user202729

Почему papert поддерживает это тогда?

Джонатан Фрех

2

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

Иона

2

@Jonah Решение JS было первым, чтобы использовать шаблон, хотя он делает это интересным способом - с модульной арифметикой и битовыми операциями вместо конкатенационных матриц. Это решение LOGO также интересно и уникально с его подходом чтения пикселей. Я не знаю достаточно ЛОГОТИПА, чтобы понять код, но, судя по описанию, он повторяет определенные шаблоны, не углубляясь в структуру фрактала (который я уже дал в подсказке 1).

нгн

10

05AB1E , 30 26 байт

'#)6F©R®í®'#ð:®ζ)2ä€ø€J˜}»

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

Emigna
источник

8

CJam , 30 байтов

"#"]{_W%_32ff&+\_Wf%\z+.+}6*N*

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

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

8

Python 2 , 205 195 ... 145 144 142 144 байта

g=lambda n,i,j,*_:g(n/2,*[~i,j,i,~j][2*(j&n>0)-(i&n>0):])if n*(i&n<=j&n)else'# '[i&n>0]
r=range(64)
for j in r:print''.join(g(32,j,i)for i in r)

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

Вдохновленный ответом Нейла .

TFeld
источник

n>>1есть n/=2.

Джонатан Фрех

aопределяется и затем используется один раз. Замена ссылки на ее значение может сэкономить четыре байта.

Джонатан Фрех

Я упустил полезное упрощение - вместо того, чтобы делать все, используя повороты, я должен был вместо этого использовать отражения. Это сэкономило мне 41 байт на мой ответ!

Нил

Я думаю, что вы можете сохранить два байта, упрощая свой [...[x],...[x]][z]выбор .

Джонатан Фрех

1

@totallyhuman Достаточно справедливо

TFeld

7

Haskell, 126 125 113 106 103 байт

e=[]:e
z=zipWith
r=reverse
m s=z(++)(r s++map(' '<$)s)$map r s++foldr(z(:))e s
unlines$m$m$m$m$m$m["#"]

Прямая реализация hint1 в спойлере.

Функция mгенерирует следующую итерацию. Основные функции применяются m6 раз. Детали к m:

m s=                          -- s is the current pattern
     zipWith(++)              -- concatenate pairwise the lines of
                (r s)++       --    the lines of s in reverse order, followed by
                map(' '<$)s   --    each char in s replaced by a space
                              -- and
                map r s++     --    each line of s reversed, followed by
                foldr ... s   --    the transposition of s


e=[]:e;foldr(zipWith(:))e     -- this right fold transposes a matrix

Редактировать: @ngn сохранил байт и @Laikoni еще 3. Спасибо!

Ними
источник

n$n$n$n$n$n["#"]короче iterate n["#"]!!6:)

ngn

@ngn: хорошо заметили. Большое спасибо!

Nimi

Вы можете использовать e=[]:e;foldr(zipWith(:))eвместо, import Data.List;transposeа затем сократить zipWith.

Лайкони

6

Java 7, 259 238 237 200 байт

void f(){char[][]o={{35}},n;for(int s=1,x,y;s<64;s*=2,o=n)for(n=new char[64][64],x=s;x-->0;)for(y=0;y<s;n[s+y++][x]=32)n[s+~y][x]=n[y][2*s+~x]=n[s+x][s+y]=o[y][x];for(char[]b:o)System.out.println(b);}

Спасли 2 байта, удалив {} в цикле x, спасибо ngn Спасли
19 байтов от различных изменений назначения, благодаря Джонатану
Спас 24 байта для печати против возврата (не знал, что это было разрешено), и
Спас 13 байтов для изменений цикла, спасибо Невай

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

Мой первый вызов, и я считаю респектабельным для Java. Использует подсказку 1 (что, кстати, неправильно, но я не могу писать комментарии). Вероятно, дальше можно играть в гольф, этот пропуск был в основном как есть, без красивой печати.

Tahg
источник

Я не уверен, что это может быть из-за разницы версий, но я проверил ваш код на TIO с использованием Java 8 , и он печатает нулевые символы вместо пробелов.

Джонатан Фрех

Конечно, спасибо, что заметили. По-видимому, Java вполне доволен отображением нулей в качестве пробелов в своих строках.

Таг

Вы можете сохранить байт, удалив s=1из цикла for и заменив int s,t,x,y;на int s=1,t,x,y;.

Джонатан Фрех

1

n[s-1-y][x]=o[y][x];n[y][t-1-x]=o[y][x];-> n[s-1-y][x]=n[y][t-1-x]=o[y][x];.

Джонатан Фрех

2

правильная матрица преобразования - [[V, H], [_, T]] (либо это, либо есть небольшая разница в вашем алгоритме, но это то, что мне нужно)

Tahg

5

J , 30 27 байт

|:@(|:@|.,|.@|:,.])^:6,.'#'

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

Оригинальная версия.

((|.,.|."1),' '"0,.|:)^:6,.'#'

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

FrownyFrog
источник

3

Python 2, 586 байт

import zlib,base64 as b
print zlib.decompress(b.b64decode('eJyVVlsOwzAI++8pJuX+d1zXDGLAUKi0pUp52ATcfj7+Wni3dF2/677ZO1dw+z/Zd3+rJU4SdkVHMcYQS9OuJVGio4N61p31+TGoQkco6eqoU6gSWdBJRrQhjhIdvLQ6YhNrqrEtUsu8yEbjmRqUWXlgYbl5EHfLC7cDQl4sxxAhO4wUv7fFPTx22sUWqOeEJ544Z3vn9FPU+ZmdHtCak6Fk3hfCx0FkOC8DF4YvmgoFMnCEwW2cDBkzftoiGy4GZaNhM8VYSl3YMEV7ctxsjLQKRCHZ3IB6+ATZpKSKmEyGrqZvEHY8lEQBWf8zbuAg0eypWG6nRqTLIzM+NPQa2faN89FlxhMY2vcTKDP7579fl0rmIpJ+grTvSyis798ghb4vM0CuVgbM1SFdvukjnFnfR1Gt3vAEngd6lGrIDdfkDU/ARwl+ecMHf5SzIzct8KhsqHANZ0FqFbpXdad5qH2DzOHJIHGM2pz26oug9i2+EBpX+cXQCpBA7/tne01lLb4wviHjtJE='))

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

Python 2, 1032 1025 байт

Мне нравится этот еще один. Но это намного дольше. Можно было бы играть в гольф, но в этом нет необходимости. Подход чиновника намного короче.

-7 благодаря Джонатану Фреху

print''.join(' '*int(x)if'/'<x<'@'else("#"*(ord(x)-64),"\n")[x<"#"]for x in'99A9A2A4A2A1E2B4A9!99B8D4G2A3A4B8!88D8B6B4A2C1G8!88A2A9A7A4E1C1A2A8!88A2A1C1E3E4A9A2A8!88G1C2A2C2A4B8D8!88B4A3A2C2A2G8B55!98A4B2E3E1A2A9A55!88B4A559A9A2A1E2!98A4B99B8G2A2!98G88D8B4A2C!88C1A2A88A2A9A4E1!992A2A88A2A1C1E4A5!992D88G1C2A4B4!992B99B4A3A2G4!777A559A4B2E1A2A4!4A2A1E2B4A559A777!4G2A3A4B99B992!4B4A2C1G88D992!5A4E1C1A2A88A2A569!1E4A9A2A88A2A1C88!C2A4B8D88G98!2A2G8B99B4A89!2E1A2A9A559A4B88!55A9A2A1E3E2B4A98!55B8G2A2C2A3A4B88!8D8B4A2C2A2C1G88!8A2A9A4E3E1C1A2A88!8A2A1C1E4A7A9A2A88!8G1C2A4B6B8D88!8B4A3A2G4D8B99!9A4B2E1A2A4A2A9A99!99996A777!99996B992!99994D299!99994A2A992!99994A2A1C88!99994G98!99994B4A98!99995A4B88!9996E2B4A89!9995C2A3A4B88!9997A2C1G88!9997E1C1A2A88!9997A9A2A88!9997B8D88!9995D8B99!9995A2A9A99!9997A9A2A4A2A1E2!9997B8D4G2A2!9995D8B6B4A2C!9995A2A9A7A4E1!9995A2A1C1E3E4A5!9995G1C2A2C2A4B4!9995B4A3A2C2A2G4!9996A4B2E3E1A2A4!9995B4A559A5!9996A4B99B4!9996G88D4!9995C1A2A88A2A4!9999A2A88A2A1C!9999D88G1!9999B99B4A1!99991A559A4B')

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

Саймон
источник

Вопрос позволяет [t]railing spaces, хотя в вашем решении пропущены некоторые пробелы.

Джонатан Фрех

Разрешение конечных пробелов означает, что мне не нужно их выводить. Это верно? Это спасло бы байты на моем втором подходе. На первом это уже сделано, потому что я удалил завершающие пробелы при сохранении моего файла ...

Simon

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

Джонатан Фрех

x=='!'->x<'#'

Джонатан Фрех,

if x.isdigit()->if"/"<x<"@"

Джонатан Фрех,

3

Mathematica, 112 90 байт

Спасибо Джонатану Фреху за помощь в сохранении 2 байтов!

""<>Nest[{{(r=Reverse)@#,r/@#},{" "+0#,#}}~Flatten~{{1,3},{2,4}}&,{{"#"}},6]~Riffle~"
"

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

По некоторым причинам Mathics печатает начальные пробелы во всех строках, кроме первой, когда печатает многострочную строку. Также Mathics не поддерживает оператора .

Объяснение:

{{Reverse@#,Reverse/@#},{" "+0#,#}}: Представляет реверс по горизонтали, реверс по вертикали, замену всего за " "и транспонирование ( это оператор транспонирования в Mathematica), соответствующий различным способам отражения или поворота изображения.
~Flatten~{{1,3},{2,4}} : Свести в определенных размерах.
Nest[ ... ,{{"#"}},6]: Применить функцию внутри до {{"#"}}6 раз.
~Riffle~"<literal newline character>" : Наведите символ новой строки между каждой строкой.
""<> : Объединить все строки вместе.

user202729
источник

Вы можете определить заменить Reverseна Rи определить, R=Reverse;чтобы сохранить два байта.

Джонатан Фрех

2

C # (.NET Core) , 1016 1002 980 955 байт

_{Спасено 14 байтов благодаря Кевину Круйссену!}
_{Сохранено 47 байт благодаря Джонатану Фреху!}

o=>{foreach(var l in new[]{35223185965568,52841249260288,0xf00c0c277f00,0x9004043ee900,0x977c7c200900,0xfee4e4300f00,0xc22727f00c00,73934616658944,0xc2000020097c,73667282210788,0x7f0000f00c27,0xe9000090043e,9895614577696,0xf0000fee430,0xc0000c227f0,4398050918032,325982355457<<21,1092065689603<<20,835235872783<<20,291765223433<<20,0x7c20090000970000,-15289957744513<<17,21955973480545<<17,68788263321667<<16,68799053409<<17,206425089091<<16,0xf00c27277f0000,618546478825<<16,650622541833<<16,0xfee430300f0000,208473439235<<18,72203117569<<18,1<<21,3<<20,15<<20,9<<20,9895936,127<<17,97<<17,67<<16,15969<<17,3829596160,662634496,16105<<16,8201<<16,806289408,4027318272,9217L<<18,537463164,806293476,4027321383,2416182334,2541517856,4276413488,3257346032,1128152720,3254779936,1124073520,2130706672,3909091472,150995095,251658494,201326786,67108931})System.Console.WriteLine(System.Convert.ToString(l,2).PadLeft(64,'0').Replace('0',' ').Replace('1','#'));}

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

объяснение

Формат вывода хранится в массиве 64-битных чисел со знаком, который идеально подходит, поскольку каждая строка имеет длину 64 символа. Пустые пространства представлены 0и #представлены1 .

Числа затем конвертируются в двоичную строку, нули проложенный слева , пока строка не должна превышать 64 символов в ширину , а затем 0и 1символы заменяются и #.

Код хранится внутри функции lamba, а точнее a System.Func<string>.

Некоторые константы в long[]сокращаются путем выполнения некоторого сдвига битов.

Ян Х.
источник

Нет ли в нем ненужного места long[] n=new[]?

Джонатан Фрех

@JonathanFrech А, ты прав, видимо, это каким-то образом пробралось туда.

Ян Х.

1

Вы бы сэкономили 4 байта, не указав символ заполнения.

Нил

1

Ну, если трейлинг lне нужен, вы можете сэкономить еще больше байтов .

Джонатан Фрех

1

Похоже, в нижней части это прослушивается.

Лохматый

2

Древесный уголь , 42 байта

#↓##ＦＥ⁵Ｘ²ι«‖↑Ｊ⁻×³ι¹±⁰ψ⟲ＯＯ⁴×²ι⟲ＣＪ⁰±φＴ×⁴ι×⁴ι

Попробуйте онлайн! Ссылка на подробную версию кода. Было бы 25 байт, если бы это работало:

#ＦＥ⁷Ｘ²ι«‖↑⟲Ｃ→⁴⟲ＣＪ⁰±φＴιι

Объяснение:

#↓##

Вручную сгенерируйте первую рекурсию, поскольку невозможно вращаться вокруг (1, 0,5). (Такое вращение имело бы смысл только если бы оно было на 180 °.)

ＦＥ⁵Ｘ²ι«

Зациклите первые пять степеней 2 (1, 2, 4, 8, 16).

‖↑

Отразите холст вертикально. Это завершает верхнюю левую четверть результата.

Ｊ⁻×³ι¹±⁰ψ⟲ＯＯ⁴×²ι

Поверните холст на 180 ° вокруг точки на полпути вверх по правой стороне. Копия оказывается в правильном положении для верхней правой четверти результата.

⟲Ｃ

Поверните холст на 90 ° вокруг правого нижнего угла. Копия верхнего правого угла заканчивается в правильном положении для нижнего правого угла результата. Копия верхнего левого угла посторонняя.

Ｊ⁰±φＴ×⁴ι×⁴ι

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

Нил
источник

2

Дьялог АПЛ , 29 байт

⎕←(((⊖,⌽)⍪⊢∘' '¨,⍉)⍣6)1 1⍴'#'

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

Oberon
источник

1

((⊖,⌽)⍪∊,⍉)⍣6⍪⍕#с ⎕ML←0.

Адам

1

Python 2 , 715 711 байт

-4 байта благодаря @ Джонатану Фреху

for k in range(64):print"".join(ord(i)*" #"[j%2]for j,i in enumerate('												<?<<<89:11222	202	4	$" 	!%$%$&%$($%&'))[k<<6:][:64]

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

officialaimm
источник

1

711 байт.

Джонатан Фрех

@JonathanFrech Спасибо, я не думал, что не было новых строк. : D

officialaimm

1

Perl 5 , 452 байта

451 байтовый код + 1 для -p.

Пакеты все данные в строку, а не красть @ Neil «s правильный ответ .

$_=unpack"B*","\x00\x00\x20\x09\x09\x7c\xc2\x33\x00\x30\x0f\x0f\xe4\x43\x33\x00\xf0\x0c\x0c\x27\x7f\x33\x00\x90\x04\x04\x3e\xe9\x33\x00\x97\x7c\x7c\x20\x09\x33\x00\xfe\xe4\xe4\x30\x0f\x33\x00\xc2\x27\x27\xf0\x0c\x33\x00\x43\x3e\x3e\x90\x04\x33\x00\xc2\x00\x00\x20\x09\x7c\x00\x00\x43\x00\x00\x30\x0f\xe4\x00\x00\x7f\x00\x00\xf0\x0c\x27\x00\x00\xe9\x00\x00\x90\x04\x3e\x00\x00\x09\x00\x00\x97\x7c\x20\x00\x00\x0f\x00\x00\xfe\xe4\x30\x00\x00\x0c\x00\x00\xc2\x27\xf0\x00\x00\x04\x00\x00\x43\x3e\x90\x09\x7c\xc2\x00\x00\x20\x00\x00\x0f\xe4\x43\x00\x00\x30\x00\x00\x0c\x27\x7f\x00\x00\xf0\x00\x00\x04\x3e\xe9\x00\x00\x90\x00\x00\x7c\x20\x09\x00\x00\x97\x00\x00\xe4\x30\x0f\x00\x00\xfe\x00\x00\x27\xf0\x0c\x00\x00\xc2\x00\x00\x3e\x90\x04\x00\x00\x43\x33\x00\x20\x09\x7c\x7c\xc2\x33\x00\x30\x0f\xe4\xe4\x43\x33\x00\xf0\x0c\x27\x27\x7f\x33\x00\x90\x04\x3e\x3e\xe9\x33\x00\x97\x7c\x20\x20\x09\x33\x00\xfe\xe4\x30\x30\x0f\x33\x00\xc2\x27\xf0\xf0\x0c\x33\x00\x43\x3e\x90\x90\x04\x37\x00\x20\x37\x00\x30\x37\x00\xf0\x37\x00\x90\x37\x00\x97\x37\x00\xfe\x37\x00\xc2\x37\x00\x43\x36\x00\x7c\xc2\x36\x00\xe4\x43\x36\x00\x27\x7f\x36\x00\x3e\xe9\x36\x00\x20\x09\x36\x00\x30\x0f\x36\x00\xf0\x0c\x36\x00\x90\x04\x36\x00\x20\x09\x09\x7c\x34\x00\x30\x0f\x0f\xe4\x34\x00\xf0\x0c\x0c\x27\x34\x00\x90\x04\x04\x3e\x34\x00\x97\x7c\x7c\x20\x34\x00\xfe\xe4\xe4\x30\x34\x00\xc2\x27\x27\xf0\x34\x00\x43\x3e\x3e\x90\x34\x00\xc2\x00\x00\x20\x34\x00\x43\x00\x00\x30\x34\x00\x7f\x00\x00\xf0\x34\x00\xe9\x00\x00\x90\x34\x00\x09\x00\x00\x97\x34\x00\x0f\x00\x00\xfe\x34\x00\x0c\x00\x00\xc2\x34\x00\x04\x00\x00\x43"=~s/[3-9](.)/$1x$&/ger;y/01/ #/;s/.{64}/$&
/g

Обратимый вывод xxdдля 451-байтового файла:

00000000: 245f 3d75 6e70 6163 6b22 422a 222c 2200  $_=unpack"B*",".
00000010: 0020 0909 7cc2 3300 300f 0fe4 4333 00f0  . ..|.3.0...C3..
00000020: 0c0c 277f 3300 9004 043e e933 0097 7c7c  ..'.3....>.3..||
00000030: 2009 3300 fee4 e430 0f33 00c2 2727 f00c   .3....0.3..''..
00000040: 3300 433e 3e90 0433 00c2 0000 2009 7c00  3.C>>..3.... .|.
00000050: 0043 0000 300f e400 007f 0000 f00c 2700  .C..0.........'.
00000060: 00e9 0000 9004 3e00 0009 0000 977c 2000  ......>......| .
00000070: 000f 0000 fee4 3000 000c 0000 c227 f000  ......0......'..
00000080: 0004 0000 433e 9009 7cc2 0000 2000 000f  ....C>..|... ...
00000090: e443 0000 3000 000c 277f 0000 f000 0004  .C..0...'.......
000000a0: 3ee9 0000 9000 007c 2009 0000 9700 00e4  >......| .......
000000b0: 300f 0000 fe00 0027 f00c 0000 c200 003e  0......'.......>
000000c0: 9004 0000 4333 0020 097c 7cc2 3300 300f  ....C3. .||.3.0.
000000d0: e4e4 4333 00f0 0c27 277f 3300 9004 3e3e  ..C3...''.3...>>
000000e0: e933 0097 7c20 2009 3300 fee4 3030 0f33  .3..|  .3...00.3
000000f0: 00c2 27f0 f00c 3300 433e 9090 0437 0020  ..'...3.C>...7. 
00000100: 3700 3037 00f0 3700 9037 0097 3700 fe37  7.07..7..7..7..7
00000110: 00c2 3700 4336 007c c236 00e4 4336 0027  ..7.C6.|.6..C6.'
00000120: 7f36 003e e936 0020 0936 0030 0f36 00f0  .6.>.6. .6.0.6..
00000130: 0c36 0090 0436 0020 0909 7c34 0030 0f0f  .6...6. ..|4.0..
00000140: e434 00f0 0c0c 2734 0090 0404 3e34 0097  .4....'4....>4..
00000150: 7c7c 2034 00fe e4e4 3034 00c2 2727 f034  || 4....04..''.4
00000160: 0043 3e3e 9034 00c2 0000 2034 0043 0000  .C>>.4.... 4.C..
00000170: 3034 007f 0000 f034 00e9 0000 9034 0009  04.....4.....4..
00000180: 0000 9734 000f 0000 fe34 000c 0000 c234  ...4.....4.....4
00000190: 0004 0000 4322 3d7e 732f 5b33 2d39 5d28  ....C"=~s/[3-9](
000001a0: 2e29 2f24 3178 2426 2f67 6572 3b79 2f30  .)/$1x$&/ger;y/0
000001b0: 312f 2023 2f3b 732f 2e7b 3634 7d2f 2426  1/ #/;s/.{64}/$&
000001c0: 0a2f 67                                  ./g

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

Дом Гастингс
источник

1

Jq 1,5 , 538 535 488 476 байт

Это простое представление. ~~Я еще не пробовал никаких причудливых кодировок.~~ Заменены 0,0 пары с функцией Z.

Еще раз спасибо Джонатану Фреху за помощь в устранении 3 байтов!

def B:recurse(if.>0then./2|floor else empty end)|.%2;def S:256+.|[B]|reverse[2:]|map(if.>0then"#"else" "end)|join("");def Z:0,0;[[Z,3,1,1,4,5,2],[1,4,5,2,2,3,Z],[Z,Z,2,3,Z],[Z,Z,3,1,1,4]]as$m|[[],[9,15,12,4,124,228,39,62],[Z,Z,Z,Z,124,228,39,62,32,48,240,144],[32,48,240,144,151,254,194,67,194,67,127,233,9,15,12,4],[124,228,39,62,32,48,240,144,32,48,240,144,151,254,194,67],[194,67,127,233,9,15,12,4,9,15,12,4,124,228,39,62]]as$c|$m[]|range(16)as$l|map($c[.][$l]|S)|join("")

Количество символов

$ wc -c picture.jq
 476 picture.jq

Пробный прогон

$ jq -Mnr -f picture.jq
                  #         #  #    #  # #####  ##    #         
                  ##        ####    #######  #   #    ##        
                ####        ##      ##    #  ### #######        
                #  #         #       #    ##### ### #  #        
                #  # ### #####   #####    #         #  #        
                ####### ###  #  ###  #    ##        ####        
                ##    #   #  ###  #  #######        ##          
                 #    ##  #####   ##### #  #         #          
                ##    #                   #         #  # #####  
                 #    ##                  ##        #######  #  
                 #######                ####        ##    #  ###
                ### #  #                #  #         #    ##### 
                    #  #                #  # ### #####    #     
                    ####                ####### ###  #    ##    
                    ##                  ##    #   #  #######    
                     #                   #    ##  ##### #  #    
    #  # #####  ##    #                   #                     
    #######  #   #    ##                  ##                    
    ##    #  ### #######                ####                    
     #    ##### ### #  #                #  #                    
 #####    #         #  #                #  # ###                
###  #    ##        ####                #######                 
  #  #######        ##                  ##    #                 
  ##### #  #         #                   #    ##                
          #         #  # #####   #####  ##    #                 
          ##        #######  #  ###  #   #    ##                
        ####        ##    #  ###  #  ### #######                
        #  #         #    #####   ##### ### #  #                
        #  # ### #####    #       #         #  #                
        ####### ###  #    ##      ##        ####                
        ##    #   #  #######    ####        ##                  
         #    ##  ##### #  #    #  #         #                  
                                          #                     
                                          ##                    
                                        ####                    
                                        #  #                    
                                        #  # ###                
                                        #######                 
                                        ##    #                 
                                         #    ##                
                                 #####  ##    #                 
                                ###  #   #    ##                
                                  #  ### #######                
                                  ##### ### #  #                
                                  #         #  #                
                                  ##        ####                
                                ####        ##                  
                                #  #         #                  
                                  #         #  #    #  # #####  
                                  ##        ####    #######  #  
                                ####        ##      ##    #  ###
                                #  #         #       #    ##### 
                                #  # ### #####   #####    #     
                                ####### ###  #  ###  #    ##    
                                ##    #   #  ###  #  #######    
                                 #    ##  #####   ##### #  #    
                                ##    #                   #     
                                 #    ##                  ##    
                                 #######                ####    
                                ### #  #                #  #    
                                    #  #                #  # ###
                                    ####                ####### 
                                    ##                  ##    # 
                                     #                   #    ##

jq170727
источник

1

Три пропускаемых пространства в B: recи 16) as $l|.

Джонатан Фрех

1

if.==0then" "else"#"end-> if.>0then"#"else" "end.

Джонатан Фрех

1

Python 2 , 174 164 154 байта (на основе матричных операций)

-10 байт благодаря ngn.
-10 байт благодаря Джонатану Фреху.

from numpy import*
s=[['#']]
exec'b=fliplr(s);s=vstack((hstack((flipud(s),b)),hstack((eye(len(s)),rot90(b)))));'*6
s[s>'#']=' '
for l in s:print''.join(l)

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

mdahmoune
источник

import *-> import*; in s.tolist()->in s

ngn

1

154 байта .

Джонатан Фрех

1

Холст , 10 байт

#６［↔ω⤢∔ω↶×

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

dzaima
источник

0

JavaScript (Node.js) , 1233 байта

_=>` 18# 9# 2# 4# 2# #5 2#2 4#
 18#2 8#4 4#7 2# 3# 4#2
 16#4 8#2 6#2 4# 2#3 #7
 16# 2# 9# 7# 4#5 #3 # 2#
 16# 2# #3 #5 3#5 4# 9# 2#
 16#7 #3 2# 2#3 2# 4#2 8#4
 16#2 4# 3# 2#3 2# 2#7 8#2
 17# 4#2 2#5 3#5 # 2# 9#
 16#2 4# 19# 9# 2# #5
 17# 4#2 18#2 8#7 2#
 17#7 16#4 8#2 4# 2#3
 16#3 # 2# 16# 2# 9# 4#5
 20# 2# 16# 2# #3 #5 4#
 20#4 16#7 #3 2# 4#2
 20#2 18#2 4# 3# 2#7
 21# 19# 4#2 2#5 # 2#
 4# 2# #5 2#2 4# 19#
 4#7 2# 3# 4#2 18#2
 4#2 4# 2#3 #7 16#4
 5# 4#5 #3 # 2# 16# 2#
 #5 4# 9# 2# 16# 2# #3
#3 2# 4#2 8#4 16#7
 2# 2#7 8#2 18#2 4#
 2#5 # 2# 9# 19# 4#2
 10# 9# 2# #5 3#5 2#2 4#
 10#2 8#7 2# 2#3 2# 3# 4#2
 8#4 8#2 4# 2#3 2# 2#3 #7
 8# 2# 9# 4#5 3#5 #3 # 2#
 8# 2# #3 #5 4# 7# 9# 2#
 8#7 #3 2# 4#2 6#2 8#4
 8#2 4# 3# 2#7 4#4 8#2
 9# 4#2 2#5 # 2# 4# 2# 9#
 42#
 42#2
 40#4
 40# 2#
 40# 2# #3
 40#7
 40#2 4#
 41# 4#2
 33#5 2#2 4#
 32#3 2# 3# 4#2
 34# 2#3 #7
 34#5 #3 # 2#
 34# 9# 2#
 34#2 8#4
 32#4 8#2
 32# 2# 9#
 34# 9# 2# 4# 2# #5
 34#2 8#4 4#7 2#
 32#4 8#2 6#2 4# 2#3
 32# 2# 9# 7# 4#5
 32# 2# #3 #5 3#5 4#
 32#7 #3 2# 2#3 2# 4#2
 32#2 4# 3# 2#3 2# 2#7
 33# 4#2 2#5 3#5 # 2#
 32#2 4# 19#
 33# 4#2 18#2
 33#7 16#4
 32#3 # 2# 16# 2#
 36# 2# 16# 2# #3
 36#4 16#7
 36#2 18#2 4#
 37# 19# 4#2`.replace(/(.)(\d+)/g,(_,c,n)=>c.repeat(n))

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

totallyhuman
источник

Ох, в чем проблема сейчас? Хм ... Я что-то упустил?

полностью человек

1

Я не понизил голосование, но, к сожалению, это может быть сжато намного больше, используя это .

Я тоже этого не сделал, но это не в духе вопроса. Паттерн был создан, предположительно, какой-то простой рекурсивной процедурой. Задача состоит в том, чтобы определить правило, при котором ваше решение будет чрезвычайно коротким.

Иона

1

Конвертировать в базу 36 для сохранения ~ 50 байтов.

Лохматый

2

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

полностью человек

0

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

o=>{foreach(var l in new[]{35223185965568,52841249260288,0xf00c0c277f00,0x9004043ee900,0x977c7c200900,0xfee4e4300f00,0xc22727f00c00,73934616658944,0xc2000020097c,73667282210788,0x7f0000f00c27,0xe9000090043e,9895614577696,0xf0000fee430,0xc0000c227f0,4398050918032,0x97cc20000200000,0xfe44300003<<20,0xc277f0000f<<20,0x43ee900009<<20,0x7c20090000970000,-0x1bcff0ffff020000,0x27f00c0000c20000,0x3e90040000430000,9017629528424448,0x300fe4e4430000,0xf00c27277f0000,0x90043e3ee90000,0x977c2020090000,0xfee430300f0000,0xc227f0f00c0000,0x433e9090040000,2097152,3145728,15728640,9437184,9895936,16646144,12713984,4390912,2093088768,3829596160,662634496,1055457280,537460736,806289408,4027318272,2416181248,537463164,806293476,4027321383,2416182334,2541517856,4276413488,3257346032,1128152720,3254779936,1124073520,2130706672,3909091472,150995095,251658494,201326786,67108931})System.Console.WriteLine(System.Convert.ToString(l,2).PadLeft(64).Replace('0',' ').Replace('1','#'));}

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

мое местоимение monicareinstate
источник

Привет, добро пожаловать в PPCG! Это выглядит почти так же, как ответ @IanH 's C # .NET . Так что, если у вас есть какие-либо улучшения для него, сделайте комментарий вместо создания нового ответа, который почти точно такой же. Что касается вашего вопроса, вы можете использовать, <s>969</s>чтобы вычеркнуть предыдущие байты.

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

4

У меня нет репутации, необходимой для комментариев.

мое местоимение monicareinstate

Пожалуйста, не пытайтесь обойти требования представителя.

Лохматый

2

Означает ли это, что в PPCG я не могу попытаться помочь другим, если моя репутация слишком низкая?

мое местоимение monicareinstate

3

@ Честно говоря, stackexchange немного резок для новичков, давайте не будем усложнять им, слишком быстро принимая злобу

ngn

0

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

_=>{var r="";for(int i=0,j,k=0;i<626;i++)for(j=0;j++<@"4#+#$#&#$##'$$&#=$*&&)$#%#&$:&*$($&#$%#):#$#+#)#&'#%##$#:#$##%#'%'&#+#$#:)#%$#$%$#&$*&:$&#%#$%$#$)*$=#&$$'%'##$#+#<$&#5#+#$##'5#&$4$*)$#5)2&*$&#$%2%##$#2#$#+#&'7#$#2#$##%#'&#;&2)#%$#&$:$4$&#%#$);#5#&$$'##$#*#$##'$$&#5#;)$#%#&$4$:$&#$%#)2&;#&'#%##$#2#$#7'&#+#$#2#$##%2%$#&$*&2)5#$)*$4$&#5'##$#+#5#&$<#+#$##'%'$$&#=$*)$#$%$#%#&$:&*$&#$%$#$%#):#$#+#&'%'#%##$#:#$##%#'&#)#+#$#:)#%$#&$($*&:$&#%#$)&&*$=#&$$'##$#&#$#+#^#a$^&^#$#^#$##%Z)[$&#\#&$S'$$&#S%$#%#&$T#$%#)T'#%##$#T#+#$#T$*&R&*$T#$#+#V#+#$#&#$##'F$*&&)$#D&*$($&#$%B#$#+#)#&'C#$##%#'%'&#G)#%$#$%$#&$F$&#%#$%$#$)G#&$$'%'##$#F$&#5#H#&$4$G)2&F%##$#2#$#J#$#2#$##%F&2)G$4$&#H#5#&$"[i]-34;){r+=i%2<1?' ':'#';if(++k%64<1)r+='\n';}return r;}

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

Использует тот же подход, этот другой ответ .

Чарли
источник

0

K (нгн / к) , 32 31 27 байт

6{,[|x;""x],'(+|+x),+x}/"#"

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

6{ }/ 6 раз сделать

+x транспонирования

|x повернуть вертикально

+|+x повернуть горизонтально

, соединять вертикально

,' соединить горизонтально

,[A;B]так же, как A,B. это помогает избежать скобок вокругA и вокруг всего выражения

""xиспользуйте элементы xкак индексы в пустой строке. Индексирование вне границ создает пробелы, поэтому это выражение будет возвращать матрицу всех пробелов того же размера, что иx

СПП
источник

Простая сложность

Ответы:

SOGL V0.12 , 17 16 14 байтов

JavaScript (ES6), 233 217 213 198 182 170 163 122 байта

LOGO, 375 341 297 295 278 + 3 байта

05AB1E , 30 26 байт

CJam , 30 байтов

Python 2 , 205 195 ... 145 144 142 144 байта

Haskell, 126 125 113 106 103 байт

Java 7, 259 238 237 200 байт

J , 30 27 байт

Оригинальная версия.

Python 2, 586 байт

Python 2, 1032 1025 байт

Mathematica, 112 90 байт

C # (.NET Core) , 1016 1002 980 955 байт

объяснение

Древесный уголь , 42 байта

Дьялог АПЛ , 29 байт

Python 2 , 715 711 байт

Perl 5 , 452 байта

Jq 1,5 , 538 535 488 476 байт

Python 2 , 174 164 154 байта (на основе матричных операций)

Холст , 10 байт

JavaScript (Node.js) , 1233 байта

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

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

K (нгн / к) , 32 31 27 байт