単純な複雑さ

17

出力

                  ＃＃＃＃＃##### ##＃         
                  ## #### #######＃＃##        
                #### ## ##＃### #######        
                ＃＃＃＃##### ###＃＃        
                ＃＃### ##### #####＃＃＃        
                ####### ###＃###＃## ####        
                ##＃＃###＃####### ##          
                 ＃## ##### #####＃＃＃          
                ##＃＃＃＃#####  
                 ＃## ## #######＃  
                 ####### #### ##＃###
                ###＃＃＃＃＃####### 
                    ＃＃＃＃### #####＃     
                    #### ####### ###＃##    
                    ## ##＃＃#######    
                     ＃＃## #####＃＃    
    ＃＃##### ##＃＃                     
    #######＃＃## ##                    
    ##＃### ####### ####                    
     ＃##### ###＃＃＃＃                    
 #####＃＃＃＃＃＃###                
###＃## #### #######                 
  ＃####### ## ##＃                 
  #####＃＃＃＃##                
          ＃＃＃##### ##### ##＃                 
          ## #######＃###＃＃##                
        #### ##＃###＃### #######                
        ＃＃＃##### ##### ###＃＃                
        ＃＃### #####＃＃＃＃                
        ####### ###＃## ## ####                
        ##＃＃####### #### ##                  
         ＃## #####＃＃＃＃＃                  
                                          ＃                     
                                          ##                    
                                        ####                    
                                        ＃＃                    
                                        ＃＃###                
                                        #######                 
                                        ##＃                 
                                         ＃##                
                                 ##### ##＃                 
                                ###＃＃##                
                                  ＃### #######                
                                  ##### ###＃＃                
                                  ＃＃＃                
                                  ## ####                
                                #### ##                  
                                ＃＃＃                  
                                  ＃＃＃＃＃#####  
                                  ## #### #######＃  
                                #### ## ##＃###
                                ＃＃＃＃##### 
                                ＃＃### ##### #####＃     
                                ####### ###＃###＃##    
                                ##＃＃###＃#######    
                                 ＃## ##### #####＃＃    
                                ##＃＃     
                                 ＃## ##    
                                 ####### ####    
                                ###＃＃＃＃    
                                    ＃＃＃＃###
                                    #### ####### 
                                    ## ##＃ 
                                     ＃＃##

末尾のスペースは許可されます。最短のソリューションが勝ちます。

hint0

ヒント1：

hint1

hint1を修正してくれてありがとう@Tahg

code-golf  ascii-art  kolmogorov-complexity 
— NGN
ソース
8
データのみが形成された方法への説明もなく挑戦@ngn出力は通常、（参照眉をひそめているcodegolf.stackexchange.com/q/126037を最初の答えは「神秘的な」部分を吹き飛ばすする傾向があるため、）
— ウリエル
16
個人的には、ルール/レシピを見つけることがタスクの一部であるこのような課題は好きではありません。それに、人がそれを見つけると、他のすべての人はそれをフォローすることができるので、そもそも投稿してみませんか？
— ルイスメンドー
11
@LuisMendoこれは興味深い議論です。最も純粋な形のコードゴルフは、「既知のソリューションを簡潔に実装する」ことです。最も純粋な形のパズルは、解決策を見つけることに関するものです-実装は関連性がないか、忙しい仕事と見なされます。1つの選択肢は、ネタバレに「トリック」を投稿することです。そうすれば、純粋なコードのゴルファーはゴルフのチャレンジとして問題を攻撃することができ、ゴルフとパズルのチャレンジの両方が好きな人は、両方を見て回避することができます。
— ジョナ
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
— ザイマ
ソース
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>`)
スニペットを展開

編集：@Shaggyのおかげで14 18バイトを保存しました。@ngnのおかげで3バイト節約されました。一緒に動作する2つのおかげで、さらに12バイト節約されました。四半期では回転ではなく反射を使用するという@ user202729の観察結果を盗むことで41バイトを節約しました。ゴルフをしていない：

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=ここを数える必要がありますか？ところで、うまくできました。
— シャギー
— シャギー
1
f=バイトカウントは必要ありませんが、コードスニペットはそれなしでは機能しません。
1
@Neil説明や追加されていないバージョンを追加できる可能性はありますか？
— ジョナ
1
@ジョナあなたがそれが役立つことを願っています。
— ニール
11

ロゴ、375 341 297 295 278 + 3バイト

-pフラグのために3バイトを追加します。これにより、デフォルトでパースペクティブモードが有効になりperspective、コマンドを実行する必要がなくなり、全体で9バイト節約されます。

WindowsでUnix（LF）改行形式を使用してFMSLogoを使用します（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は反射をサポートしていないため、3D（perspective）モードに入り、コンピューター画面に平行な軸を中心に亀を180度回転させることによってのみシミュレーションを行うことができます。

これはヘルパー関数を定義します。ヘルパー関数はg、2つのパラメーターl（画像側の長さ）とw（画像の描画に使用される手順）を指定し、その反射画像の3つのコピーを描画します。（質問のヒントを参照）プロシージャhはメインプロシージャを実行します。

— user202729
ソース
おそらく90 fd->のようないくつかのスペースを省略して90fd、数バイトを節約できます。
— ジョナサンフレッチ
@JonathanFrech残念ながら、FMSLogoはそれをサポートしていません。
— user202729
なぜpapertはそれをサポートするのですか？
— ジョナサンフレッチ
2
これは、ビットパッキングではなく、実際にパターンを活用する唯一の答えですか？
— ジョナ
2
@Jonah JSソリューションは最初にパターンを活用しましたが、興味深い方法でそれを行います-行列を連結する代わりにモジュラー算術演算とビット演算を使用します。このロゴソリューションは、ピクセル読み取りのアプローチにより、ユニークで興味深いものです。私はコードを理解するのに十分なロゴを知りませんが、説明によって判断すると、フラクタルの構造をたどることなく特定のパターンを繰り返します（すでにhint1で渡しました）。
— NGN
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)

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

NeilのJS回答に触発されました。

— TFeld
ソース
n>>1ですn/=2。
— ジョナサンフレッチ
a定義されてから1回使用されます。参照をその値に置き換えると、4バイト節約できます。
— ジョナサンフレッチ
便利な単純化を見落としていました-回転を使用してすべてを行うのではなく、代わりに反射を使用する必要がありました。回答で41バイト節約できました！
— ニール
選択を簡素化する[...[x],...[x]][z]ことで2バイトを節約できると思います。
— ジョナサンフレッチ
1
@totallyhumanフェア
— TFeld
7

ハスケル、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);}

xループの{}を削除して2バイトを節約しました。ngn
がさまざまな割り当ての変更から19バイト
を
節約しました。おかげでネバイ

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

私の最初の挑戦、そして私はJavaに対して立派だと思います。ヒント1を使用します（これは間違っていますが、コメントを書くことができません）。おそらくさらにゴルフをすることができます。このパスは基本的にはそのままで、きれいに印刷されていません。

— ターグ
ソース
バージョンの違いが原因かどうかはわかりませんが、Java 8を使用してTIOでコードをテストし、スペースではなくヌル文字を出力します。
— ジョナサンフレッチ
気づいてくれてありがとう。どうやら、Javaは文字列内の空白としてnullを表示することに非常に満足しています。
— ターグ
あなたは削除することで、バイトを保存することができs=1、あなたのためのループからと交換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
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バイト

これがもう一つ好きです。しかし、それはずっと長いです。ゴルフはできますが、その必要はありません。officialaimmのアプローチははるかに短いです。

-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あなたのソリューションはいくつかのスペースを省略していますが、質問は可能です。
— ジョナサンフレッチ
末尾のスペースを許可することは、それらを出力する必要がないことを意味します。あれは正しいですか？2番目のアプローチではバイトを節約できます。私のファイルを保存しながら、私は末尾のスペースを削除したため、それがすでに行われている最初の1 ...オン
— サイモン
確かではありませんが、不足しているスペースを許可せず、追加のスペースを許可すると解釈しました。
— ジョナサンフレッチ
x=='!'->x<'#'
— ジョナサンフレッチ
if x.isdigit()->if"/"<x<"@"
— ジョナサンフレッチ
3

Mathematica、112 90バイト

2バイトの節約にご協力いただいたJonathan Frechに感謝します！

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

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

何らかの理由で、Mathicsは複数行の文字列を印刷するとき、最初の行を除くすべての行に先頭のスペースを印刷します。また、Mathicsは演算子をサポートしていません。

説明：

  • {{Reverse@#,Reverse/@#},{" "+0#,#}}：画像を反射または回転するさまざまな方法に対応する、逆水平、逆垂直、replace-all-by- " "、およびトランスポーズ（Mathematicaではトランスポーズ演算子）を表す。
  • ~Flatten~{{1,3},{2,4}} ：特定の寸法で平坦化します。
  • Nest[ ... ,{{"#"}},6]：内部の関数を{{"#"}}6回適用します。
  • ~Riffle~"<literal newline character>" ：各行の間に改行文字を挿入します。
  • ""<> ：すべての文字列を結合します。
— user202729
ソース
あなたは置き換える定義することができるReverseとRして定義するR=Reverse;2つのバイトを保存します。
— ジョナサンフレッチ
2

C＃（.NET Core）、1016 1002 980 955バイト

Saved 14 bytes thanks to Kevin Cruijssen!
Saved 47 bytes thanks to Jonathan Frech!

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','#'));}

Try it online!

Explanation

The format of the output is stored inside an array of signed 64-bit numbers, which fits perfectly since each line is 64 characters long. Empty spaces are represented by 0 and # is represented by 1.

The numbers are then converted to their binary string, zeros are padded left until the string is 64 characters wide and then the 0 and 1 characters are replaced with   and #.

The code is stored inside a lamba function, more specifically a System.Func<string>.

Some constants in the long[] are shortened by performing some bit-shifting.

— Ian H.
ソース
Is there not an unnecessary space in long[] n=new[]?
— Jonathan Frech
@JonathanFrech Ah you are right, apparently it snuck in there somehow.
— Ian H.
1
You would save 4 bytes by not having to specify the padding character.
— Neil
1
Well, if the trailing l is not needed, you can probably save even more bytes.
— Jonathan Frech
1
Looks like the bottom of this is bugged.
— Shaggy
2

Charcoal, 42 bytes

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

Try it online! Link is to verbose version of code. Would be 25 bytes if this worked:

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

Explanation:

#↓##

Manually generate the first recursion, since it's not possible to rotate around (1, 0.5). (Such a rotation would only make sense if it was 180°.)

ＦＥ⁵Ｘ²ι«

Loop over the first five powers of 2 (1, 2, 4, 8, 16).

‖↑

Reflect the canvas vertically. This completes the top left quarter of the result.

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

Rotate the canvas 180° around a point half-way up the right-hand side. The copy ends up in the correct position for the top right quarter of the result.

⟲Ｃ

Rotate the canvas 90° around the bottom right corner. The copy of the top right corner ends up in the correct position for the bottom right corner of the result. The copy of the top left corner is extraneous.

Ｊ⁰±φＴ×⁴ι×⁴ι

Trim the canvas to the size we want. The trim starts at the cursor or the top left of the canvas, whichever is bottom rightmost. The cursor is therefore sent to (0, -1000) to ensure that it doesn't interfere with the trim.

— Neil
ソース
1

Perl 5, 452 bytes

451 bytes code + 1 for -p.

Packs all the data into the string, rather than stealing @Neil's correct answer.

$_=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

Reversible output from xxd for 451 byte file:

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

Try it online!

— Dom Hastings
ソース
1

Jq 1.5, 538 535 488 476 bytes

This is a straightforward representation. I haven't attempted any fancy encodings yet. Replaced 0,0 pairs with Z function.

Thanks again to Jonathan Frech for helping eliminate 3 bytes!

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("")

Character count

$ wc -c picture.jq
 476 picture.jq

Sample run

$ jq -Mnr -f picture.jq
                  #         #  #    #  # #####  ##    #         
                  ##        ####    #######  #   #    ##        
                ####        ##      ##    #  ### #######        
                #  #         #       #    ##### ### #  #        
                #  # ### #####   #####    #         #  #        
                ####### ###  #  ###  #    ##        ####        
                ##    #   #  ###  #  #######        ##          
                 #    ##  #####   ##### #  #         #          
                ##    #                   #         #  # #####  
                 #    ##                  ##        #######  #  
                 #######                ####        ##    #  ###
                ### #  #                #  #         #    ##### 
                    #  #                #  # ### #####    #     
                    ####                ####### ###  #    ##    
                    ##                  ##    #   #  #######    
                     #                   #    ##  ##### #  #    
    #  # #####  ##    #                   #                     
    #######  #   #    ##                  ##                    
    ##    #  ### #######                ####                    
     #    ##### ### #  #                #  #                    
 #####    #         #  #                #  # ###                
###  #    ##        ####                #######                 
  #  #######        ##                  ##    #                 
  ##### #  #         #                   #    ##                
          #         #  # #####   #####  ##    #                 
          ##        #######  #  ###  #   #    ##                
        ####        ##    #  ###  #  ### #######                
        #  #         #    #####   ##### ### #  #                
        #  # ### #####    #       #         #  #                
        ####### ###  #    ##      ##        ####                
        ##    #   #  #######    ####        ##                  
         #    ##  ##### #  #    #  #         #                  
                                          #                     
                                          ##                    
                                        ####                    
                                        #  #                    
                                        #  # ###                
                                        #######                 
                                        ##    #                 
                                         #    ##                
                                 #####  ##    #                 
                                ###  #   #    ##                
                                  #  ### #######                
                                  ##### ### #  #                
                                  #         #  #                
                                  ##        ####                
                                ####        ##                  
                                #  #         #                  
                                  #         #  #    #  # #####  
                                  ##        ####    #######  #  
                                ####        ##      ##    #  ###
                                #  #         #       #    ##### 
                                #  # ### #####   #####    #     
                                ####### ###  #  ###  #    ##    
                                ##    #   #  ###  #  #######    
                                 #    ##  #####   ##### #  #    
                                ##    #                   #     
                                 #    ##                  ##    
                                 #######                ####    
                                ### #  #                #  #    
                                    #  #                #  # ###
                                    ####                ####### 
                                    ##                  ##    # 
                                     #                   #    ##
— jq170727
ソース
1
Three omittable spaces in B: rec and 16) as $l|.
— Jonathan Frech
1
if.==0then" "else"#"end -> if.>0then"#"else" "end.
— Jonathan Frech
1

Python 2, 174 164 154 bytes (based on matrix operations)

  • -10 bytes thanks to ngn.
  • -10 bytes thanks to Jonathan Frech.
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)

Try it online!

— mdahmoune
ソース
import * -> import*; in s.tolist() -> in s
— ngn
1
— Jonathan Frech
0

JavaScript (Node.js), 1233 bytes

_=>` 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))

Try it online!

— totallyhuman
ソース
Ooh, what's the problem now? Erm... Am I missing something?
— totallyhuman
1
I didn't downvote, but, fyi, it can be compressed much more using this.
I didn't either, but this isn't in the spirit of the question. The pattern was generated, presumably, by some simple recursive procedure. The challenge is determine the rule, at which point your solution will be extremely short.
— Jonah
1
Convert to base 36 to save ~50 bytes.
— Shaggy
2
I am completely aware that this is not the optimal solution or the shortest solution or a clever one. I simply tried using an algorithm and it ended up being this. This is, however, a perfectly valid solution and hence doesn't deserve downvotes. Boring solutions should not be upvoted but they shouldn't be downvoted either.
— totallyhuman
0

C# (.NET Core), 976 969 bytes

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','#'));}

Try it online!

— my pronoun is monicareinstate
ソース
Hi, welcome to PPCG! This looks almost exactly the same as @IanH's C# .NET answer.. So if you have any improvements for his, make a comment instead of creating a new answer that is almost exactly the same. As for your question, you can use <s>969</s> to cross out the previous bytes.
— Kevin Cruijssen
4
I do not have the reputation needed to comment.
— my pronoun is monicareinstate
Please don't try to circumvent the rep requirements.
— Shaggy
2
Does this mean that in PPCG I cannot try to help others if my reputation is too low?
— my pronoun is monicareinstate
3
@Shaggy to be fair, stackexchange is a bit harsh on newcomers, let's not make it harder for them by assuming malice too quickly
— ngn
0

C# (.NET Core), 739 bytes

_=>{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;}

Try it online!

Uses the same approach is this other answer.

— Charlie
ソース
0

K (ngn/k), 32 31 27 bytes

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

Try it online!

6{ }/ 6 times do

+x transpose

|x reverse vertically

+|+x reverse horizontally

, concatenate vertically

,' concatenate horizontally

,[A;B] is the same as A,B. it helps avoid parentheses around A and around the whole expression

""x use the elements of x as indices in the empty string. out-of-bounds indexing produces spaces, so this expression will return an all-spaces matrix, same size as x

— ngn
ソース
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.