简单复杂

17

输出量

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

允许尾随空格。最短的解决方案获胜。

提示0

提示1：

hint1

感谢@Tahg纠正了hint1

code-golf  ascii-art  kolmogorov-complexity 
— ngn
source
8
@ngn仅输出挑战，而对数据的形成方式没有任何解释，通常对此感到厌烦（请参阅codegolf.stackexchange.com/q/126037），因为第一个答案往往会吹走“神秘的”部分
— Uriel
16
我个人不喜欢这样的挑战，因为要找出规则/配方是任务的一部分。此外，一旦有人找到了它，其他所有人都可以跟随它，那么为什么不首先发布它呢？
— 路易斯·门多
11
@LuisMendo这是一个有趣的论点。最纯粹的代码高尔夫是关于“简洁地实现已知解决方案”。最纯粹的困惑在于寻找解决方案-实施既不相关也不被认为是忙碌的工作。一种选择是在扰流板上张贴“技巧”。这样一来，纯代码的高尔夫球手就可以将挑战当作高尔夫球挑战来进攻，而喜欢高尔夫球和拼图挑战的人则可以避免寻找并解决这两个问题。
— 约拿（Jonah）
5
我认为“神秘”部分绝对值得一看。尽管一个答案可能找到了解决之道，但是其余的问题仍然是常规的代码挑战……并且对于那些无论如何都希望一开始就找到模式的人来说，这是一个很好的挑战。
— 完全人类
3
@ H.PWiz，我不确定+ 26 / -7是否真的“很受欢迎”。它看起来更像是“接收不佳，但设法以足够快的速度达到HNQ以获得不正确的分数”。
— 彼得·泰勒

Answers:

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
— 宰马
source
1
等待这是如何工作的
— Conor O'Brien
@ ConorO'Brien刚刚添加了一个解释：p
— dzaima
哦，不错的``````
— Conor O'Brien
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个字节。多亏了两个人的共同努力，又节省了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;
}
— 尼尔
source
您需要在f=这里数吗？顺便说一句，做得很好。
— 毛茸茸的
— 粗野的
1
您不需要f=字节数，但是没有它，代码段将无法工作。
1
@Neil有机会添加解释或非公开版本吗？
— 约拿（Jonah）
1
@Jonah希望对您有所帮助。
— 尼尔
11

LOGO，375 341 297 295 278 + 3字节

由于-pflag 增加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执行主要过程。

— 用户名
source
您可能会省略一些空格，例如90 fd-> 90fd并节省一些字节。
— 乔纳森·弗雷希
@JonathanFrech不幸的是，FMSLogo不支持该功能。
— user202729
那么为什么papert 支持它？
— 乔纳森·弗雷希
2
这是唯一真正利用模式而不是位打包的答案吗？
— 约拿（Jonah）
2
@Jonah JS解决方案是第一个利用该模式的方法，尽管它以一种有趣的方式进行了使用-使用模块化算术和位运算，而不是连接矩阵。这种LOGO解决方案也很有趣，它的像素读取方法也很独特。我不了解足够的LOGO来理解代码，但是从描述来看，它重复了某些模式，而没有完全遵循分形的结构（我已经在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 Answer启发。

— 场
source
n>>1是n/=2。
— 乔纳森·弗雷希
a被定义，然后使用一次。用其值替换其引用可以节省四个字节。
— 乔纳森·弗雷希
我忽略了一个有用的简化方法-我应该使用反射代替，而不是使用旋转来做所有事情。它为我节省了41个字节！
— 尼尔
我认为您可以通过简化[...[x],...[x]][z]选择来节省两个字节。
— 乔纳森·弗雷希
1
@totallyhuman足够公平
— TF
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个。谢谢！

— 妮米
source
n$n$n$n$n$n["#"]短于iterate n["#"]!!6:)
— ngn
@ngn：发现得很好。非常感谢！
— nimi
您可以使用e=[]:e;foldr(zipWith(:))e代替，import Data.List;transpose然后缩短zipWith。
— Laikoni
6

爪哇7，259238237字节

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个字节
为print vs return保存了24个字节（不知道这是允许的），以及
为循环更改保存了13个字节，谢谢Nevay

在线尝试！

我的第一个挑战是，我认为Java是值得尊重的。使用提示1（顺便说一句是错误的，但我不能写评论）。它可能可以打得更远，此通行证基本上是原样，没有漂亮的印刷。

— 塔赫
source
我不确定这是否是由于版本差异引起的，但是我使用Java 8在TIO上测试了您的代码，并且它显示的是空字符而不是空格。
— 乔纳森·弗雷希
的确如此，感谢您的注意。显然，Java很高兴在其Strings中将空值显示为空格。
— 塔赫格
您可以通过删除保存一个字节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
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感谢Jonathan Frech

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')

在线尝试。

— 西蒙
source
这个问题允许[t]railing spaces，尽管您的解决方案省略了一些空格。
— 乔纳森·弗雷希
允许尾随空格意味着，我不必输出它们。那是对的吗？我的第二种方法可以节省字节数。第一个已经完成，因为我在保存文件时删除了尾随空格...
— Simon
我不确定，但是我将其解释为允许额外的空格，不允许丢失空格。
— 乔纳森·弗雷希
x=='!'->x<'#'
— 乔纳森·弗雷希
if x.isdigit()->if"/"<x<"@"
— 乔纳森·弗雷奇
3

Mathematica，112个 90字节

感谢Jonathan Frech帮助节省2个字节！

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

在线尝试！（数学）

由于某些原因，在打印多行字符串时，Mathics在除第一行外的所有行中打印前导空格。而且数学不支持运算符。

说明：

  • {{Reverse@#,Reverse/@#},{" "+0#,#}}：代表水平，反垂直，全部替换" "和转置（在Mathematica中为转置运算符），对应于反射或旋转图像的不同方式。
  • ~Flatten~{{1,3},{2,4}} ：将特定尺寸展平。
  • Nest[ ... ,{{"#"}},6]：将内部功能应用{{"#"}}6次。
  • ~Riffle~"<literal newline character>" ：在每行之间插入换行符。
  • ""<> ：将所有字符串连接在一起。
— 用户名
source
您可以定义“替换Reverse为” R并定义R=Reverse;为保存两个字节。
— 乔纳森·弗雷希
2

C＃（.NET核心），1016个 1002 980 955字节

感谢Kevin Cruijssen，节省了14个字节！
感谢乔纳森·弗雷希（Jonathan Frech），节省了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函数（更具体地讲）内部System.Func<string>。

long[]通过执行一些移位，可以缩短中的某些常量。

— 伊恩·H。
source
里面没有多余的空间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）以确保它不会干扰修剪。

— 尼尔
source
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
source
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
source
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
source
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
source
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
source
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
source
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
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.