打印堆栈交换图标

19

挑战

打印或返回Stack Exchange网站图标，如下所示：

 ___________________
/                   \
---------------------
|                   |
---------------------
|                   |
---------------------
\__________    _____/
           |  /
           | /
           |/

这是代码高尔夫球，因此每种语言中最短的答案将获胜。

code-golf  string  ascii-art  kolmogorov-complexity 
— 音乐人523
source
2
左上角是否打算稍微对准？
— ETHproductions'Jul
@ETHproductions本来是想要的，但是我现在要更改它。两种方法看起来都有些尴尬。
— musicman523
2
实际输出为219字节，以供参考。
— totallyhuman
允许尾随行和/或行上的尾随空格，对吗？
— dzaima
1
— 泰勒·斯科特

Answers:

43

操作Flashpoint脚本语言，263 195字节

f={r="                   ";t="---------------------\n";s=" ___________________\n/"+r+"\\n"+t+"|"+r+"|\n"+t+"|"+r+"|\n"+t+"\__________    _____/\n           |  /\n           | /\n           |/";s}

这不是工作的正确工具。

致电：

hint call f;

输出：

格式化失败，因为字体不是等宽的。

— 稳定箱
source
49
正是什么使您着眼于挑战并认为“哦，我应该在Flashpoint行动中回答这一点”使我感到困惑……
— totallyhuman 2017年
7
@totallyhuman我猜它的脚本语言很有趣。它有很多怪癖和局限性，因此有时您需要使用一些奇怪的解决方法，这使其变得有趣（但还不是很实用）。
— Steadybox'7
5
对答案进行硬编码可能会给您更好的分数。
— NieDzejkob'7
2
@NieDzejkob现在它比仅对输出进行硬编码要短，但比以前的版本更无聊。
— Steadybox
@totallyhuman尤其是面对这个挑战时，我想测试该语言在Kolmogorov复杂性挑战中的表现（这远远不理想）。
— Steadybox '17
11

木炭，38 37 33 30字节

←×_χ↓Ｆ/||⟦ι¹¹⟧\×_⁹‖Ｂ_×ψ⁴↙↙³↑↑³

在线尝试！链接是详细版本的代码。编辑：设法通过反射来保存一个字节，尽管@CarlosAlejo显示实际上它可以以37个字节完成而无需反射。通过绘制左侧的¾并反映最后的¼，又节省了4个字节。编辑：以前的33个字节的答案取决于ReflectButterflyOverlap()不使用反射叠印重叠区域，因此，如果此行为发生变化，我寻求了一个不依赖于此的解决方案，并且由于我的原因，结果反而变得更短了创造性地使用打印数组。说明：

←×_χ                            Print 10 `_`s leftwards (top row)
    ↓                           Move down to the next row
     Ｆ/||                       For each character in the string `/||`
          ι                     Current character
           ¹¹                   Integer 11, prints as `-----------`
         ⟦   ⟧                  Put both into an array
                                Implicitly print on separate lines
              \                 Implicitly print `\`
               ×_⁹              Implicitly print 9 `_`s
                  ‖Ｂ            Reflect right, overlapping the axis
                    _           Implicitly print `_`
                     ×ψ⁴        Implicitly delete 4 characters
                        ↙↙³     Move down left and print three `/`s
                           ↑↑³  Move up and print three '|'s
— 尼尔
source
2
很好玩。我喜欢这个问题有四个木炭答案！‖ＢＯ上次使用该语言不是我所用的语言-将来我必须牢记这一点。
— DLosc
我必须亲自了解 “反射最后的¼”的含义。确实表现不错！
— 查理
8

///，98字节

/'/  //&/
"""
|!! |//%/\\\/
!'|//#/_____//"/-------//!/'''' / ###____
\/!! \\&&
"""
\\##''#%'% %\/

在线尝试！或者，以交互方式查看它！

— 科纳·奥布莱恩
source
3
是否有实用程序可以让我查看///程序的不同“步骤”？（每次替换后部分执行。）这可以帮助我更好地理解它们。
— CAD97
@ CAD97我一直在摆弄在线解释器，它通常带有调试选项，但是在线解释器对参数进行排序的方式并不起作用。您可以自己获取翻译的副本，然后执行类似的操作perl slashes.pl -d1 code.txt。我目前正在///的在线执行环境中工作，但这可能需要一些时间。
— 科纳·奥布赖恩
3
@ CAD97说网上的事了，看看吧！
— Conor O'Brien
8

的JavaScript（ES6），113个 112字节

（由于@Craig Ayre而节省了一个字节。）

let f=

_=>` _19
/ 19\\
-21
| 19|
-21
| 19|
-21
\\_10 4_5/
 11| 2/
 11| /
 11|/`.replace(/.(\d+)/g,([a],b)=>a.repeat(b))
 
 console.log(f());
展开摘要

— 里克·希区柯克
source
看起来替换功能之前您有一个杂散的空间。我刚刚为我的JS解决方案提出了一个113字节的类似更新。不知道我应该发布它还是让你拥有它。
— 毛茸茸的
啊，等等，直到我发布我的消息之前，您才知道您已经发布了解决方案。当我上电脑时，我将删除我的，您可以使用保存一个字节replace(/.(\d+)/g,(a,b)=>a[0].repeat(b))。
— 毛茸茸的
谢谢，毛茸茸的。我已经编写了一个程序来自动执行这种类型的答案，并且让它输出不需要的空间是很愚蠢的。您建议的replace陈述肯定是一种改进，现在我已将其纳入程序中。
— 里克·希区柯克
1
您可以保存符合a以下条件的字节数组([a],b)=>a.repeat(b))吗？
— Craig Ayre
是啊谢谢！我不熟悉该语法。
— 里克·希区柯克
7

SOGL V0.12，32 31 个字节

^$∙r↑Ψ«2τγæΕž‘╬Æ╬⁷"ƧΡ⅟?0Ξ³‘6«8ž

在这里尝试！

说明：

...‘               push a quarter of the icon
    Β             palindromize vertically
      ╬⁷           palindromize horizontally (these two should be ╬3 together, but spacing doesn't work correctly (though now it does since I fixed it))
        "...‘      push the extention
             6«8ž  at coordinates [12; 8] in the quad-palindromized image put that in

季度：

 __________
/
-----------
|
-----------

另一部分：

    
|  /
| /
|/
— 宰马
source
“一起”？“槽”？另外，花了一点时间才弄清楚.解释中的意思string。也许使用^...'和"...'？
— CalculatorFeline
@CalculatorFeline我通常...对压缩字符串（也就是废话）进行处理，但是最近我开始做一两个。随时纠正我的错误和语法：p
— dzaima
7

Python 2，115字节，更具创意

t,u,v,w,x,y,z='\n -/\\_|';k=w+t+11*u+z;i=t+21*v+t
print u+19*y+t+w+19*u+x+(i+z+19*u+z)*2+i+x+10*y+4*u+5*y+k+u,k,k+w

在线尝试！

Python 2，102字节，无聊的想法

print'eNrjUojHBFz6CpgghksXG+CqwaK2hgpqYxDuASkDM/S5kDUqKKDxUbn6XADUmClx'.decode('base64').decode('zip')

在线尝试！

— mdahmoune
source
2
我对此不赞成，因为我已经看到这种方法使用了太多次了。一遍又一遍地看着真无聊。
— R. Kap
8
@ R.Kap除非有更短的方法，否则这是一个相当随意的理由。
— 丹尼斯
1
@Dennis也许吧，但我仍然坚持我的观点，并有权表达它。我已经看到这种方法在此类挑战中使用了无数次，并且在OP方面几乎不需要甚至没有创造力，至少在我看来，这是Kolomogorov复杂性挑战的重要方面，因此，我拒绝投票的原因。
— R. Kap
2
@ R.Kap如果通用压缩算法可以轻松击败手动压缩算法，那将是一个难题，而不是答案。我什至没有设法用Jelly打败Bubblegum，而减压在Jelly中的开销很小。
— 丹尼斯
2
@Dennis我在这里甚至都不在谈论代码长度。我说的是努力和创造力，我认为此答案无法用一种人可以做得更多的语言来展示，这就是我拒绝投票的原因。现在，如果您不同意我的推理，那很好。在这种情况下，让我们只同意不同意并在此对话结束之前就结束对话。:)
— R. Kap
6

Python 2，124字节

a,b,d,e,f,g,h=' _-|/\\\n';r=d*21+h+e+a*19+e+h;n=f+h+a*11+e;print a+b*19+h+f+a*19+g+h+r*2+r[:22]+g+b*10+a*4+b*5+n+a*2+n+a+n+f

在线尝试！

— 卡普
source
您永远不会使用c，因此可以消除3个字节。在线尝试！
— musicman523
@ musicman523我什至不知道为什么把它放在那里。感谢您的接见！:)
— R. Kap
6

C（gcc），187字节

感谢Cody Gray，节省了2个字节，感谢Keyu Gan，节省了3个字节！

#define a"         "
#define s a" "a
#define l"\n---------------------\n"
f(){puts(" ___________________\n/"s"\\"l"|"s"|"l"|"s"|"l"\\__________    _____/\n"a"  |  /\n"a"  | /\n"a"  |/");}

在线尝试！

— 音乐人523
source
2
puts如果可以接受尾随的换行符，则它的长度会短得多。
— 科迪·格雷
您可以使用f()代替main()。功能也是可以接受的。
— Keyu Gan'7
5

锈，181字节

||" ___________________
/2\\
1
1
3
\\__________    _____/
4|  /
4| /
4|/".replace("1","3
|2|").replace("2",&" ".repeat(19)).replace("3",&"-".repeat(21)).replace("4",&" ".repeat(11))

在线尝试！

锈，184字节

此版本可能更具高尔夫球性，因为replace每个版本花费更少的字节数。第一个replace不是循环的一部分，因为它将双重任务更改拉到sa String而不是a中&'static str。

||{let mut s=" 5__5__5
/2\\
1
1
3
\\55    5/
4|  /
4| /
4|/".replace("1","3
|2|");for p in vec![("2"," ",19),("3","-",21),("4"," ",11),("5","_",5)]{s=s.replace(p.0,&p.1.repeat(p.2))}s}

在线尝试！

— CAD97
source
5

C，167字节

i;char*d=" q    /()\\   A   |()|    A   |()|    A   \\h#c/  #&|!/   #&| /   #&|/",c,b;main(j){while(c=d[i++],b=c%5==2||c>123?c:c>95?95:c>45?45:c>=32?32:++c,i<47)for(j=c;j-->=b;)putchar(b);}

在线尝试！

注意：上方许多明显的空格实际上是制表符。

可读版本：

i;
char *d = " q   /()\\   A   |()|    A   |()|    A   \\h#c/  #&|!/   #&| /   #&|/", c, b;
main(j) {
    while(
        c = d[i++],
        b = c % 5==2 || c > 123 ? c:
            c > 95 ? 95:
            c > 45 ? 45:
            c >= 32 ? 32:
            ++c,
        i < 47
    )
        for(j = c; j-- >= b;)
            putchar(b);
}

说明：

数据数组d将答案编码为原义的单个字符和编码的重复字符。数据数组中的每个字符c都映射到基本字符b和许多重复项。然后将其打印多次。

仅单独使用的字符（斜杠和竖线）具有ASCII码47、92和124。其中两个可以被5整除，其余为2 (c%5=2||c>123)。我找不到更短的条件来测试所有这三个。

重复的字符（下划线，破折号和空格）分别为ASCII码95、45和32，并以较高的ASCII码进行编码-每次重复增加一个。因此，例如，一个空格只是一个空格，但是下一个ASCII字符（感叹号）可以编码两个空格。如果编码字符由于满足上述模数条件而不合适，则可以将其拆分，如＃＆一样以表示十一个空格。使用相同的技术来避免空格和破折号字符范围之间的重叠。

最终，十个换行符被编码为制表符，以保存用反斜杠转义换行符所花费的字节，然后增加以进行打印（++c）。

— iv
source
做得好！我知道那里有更好的C答案。
— musicman523
谢谢！这是一个有趣的挑战。我花了大约四个小时在上面，所以我很高兴最后解决了这个问题。
— jiv
4

木炭，49 37字节

↓⁵\…_χ↓↓³↗↗³…_⁵↑/↑⁵↖\←…_¹⁹↓ /Ｆ³«Ｐ²¹¶¶

在线尝试！

最后我可以打些高尔夫球了。该答案（与所有其他木炭答案不同）不使用反射，而是一次绘制所有轮廓，最后留下水平条。

链接到详细版本。

— 查理
source
“与其他所有木炭答案都不一样”实际上，我的第一个答案也没有使用反射，但是我承认我并没有发现从左垂直线开始画图的机会。（我们的解决方案之间的唯一其他变化是，您在使用Times的地方使用Range，\在我刚刚打印:UpLeft1 的地方打印。）
— Neil
尽管似乎反思已经到来之路……
— 尼尔（Neil）
而且那是我的钥匙不起作用的两倍……
— Neil
3

泡泡糖，40个字节

通过删除结尾的换行符节省了1个字节，谢谢@ovs！

00000000: 5388 c704 5cfa 0a98 2086 4b17 1be0 aac1  S...\... .K.....
00000010: a2b6 860a 6a63 10ee 0129 0333 f4b9 9035  ....jc...).3...5
00000020: 2a28 a0f1 51b9 fa00                      *(..Q...

在线尝试！

— 音乐人523
source
没有尾随换行符，它将获得40个字节。
— ovs '17
谢谢！我认为我的文本编辑器会自动插入
— 。– musicman523
您是如何创建的？zlib.compress(s.encode(), 9)输出46个字节，答案似乎是zlib。
— NieDzejkob
根据Dennis的建议，我曾经zopfli --deflate生成原始的DEFLATE流，然后xxd将其转换为xxd格式。我相信会zlib留下校验和，或者由于某些其他原因而不是原始的DEFLATE流。
— musicman523
3

木炭，38字节

←…_χＰ↑⁵Ｐ\Ｆ³«↑Ｐ¹¹↑»↗¹…_χ‖ＢＭ²¦⁷Ｐ↓⁴… ⁴↙↙³

在线尝试！

我以原始形式使用卡洛斯的答案作为起点，但利用了水平对称性，通过反射节省了很多时间。（垂直对称是不值得的，因为下划线最终出现在错误的行上。）您可以在此处的每一步看到画布的演变。

这是详细版本。

— DLosc
source
顺便说一句，您可以使用它-d来显示每个步骤（也很抱歉，我已经改变了很多木炭，我不确定很多新想法是否很有用，尤其是内置于山羊的ascii-art和Wolfram语言的一部分哈哈）
— ASCII码，仅ASCII
1
— ASCII码，仅ASCII，2009年
3

Python 2中，119个 117 116字节

print''.join(' \n-/|\\_'[ord(x)/8-4]*int('1245abjl'[ord(x)%8],36)for x in' V(8&H(7(@&@(7(@&@(7(HT"S8(%@!8(%@ 8(%@8')

在线尝试！

一段折磨的游程编码...

编辑：通过替换长度集节省3个字节：

[1,2,4,5,10,11,19,21][ord(x)%8]

与

int('1245abjl'[ord(x)%8],36)

— 查斯·布朗
source
哇！我正在尝试自己想出一种有效的方法。
— GarethPW
漂亮的代码，但似乎是119个字节？
— mdahmoune
@mdahmoune：非常正确- r''在检查长度时忘了使用...
— Chas Brown
3

C ++ 11 - 162个 159 154 152 150字节

MSVC：

void f(){char*i="b t_b\nb/t b\\b\nv-b\nb|t b|b\nv-b\nb|t b|b\nv-b\nb\\k_e f_b/b\nl b|c b/b\nl b|b b/b\nl b|b/";while(*i)cout<<string(*i++-97,*i),i++;}

GCC：（+ 4个字符）

int f(){char*i="b t_b\nb/t b\\b\nv-b\nb|t b|b\nv-b\nb|t b|b\nv-b\nb\\k_e f_b/b\nl b|c b/b\nl b|b b/b\nl b|b/";while(*i){cout<<string(*i-97,*(i+1));i+=2;}}

输入字符串i以字符对形式编码：

  1. 要重复的字符数（添加到“ a”后即可清晰辨认）
  2. 要打印的字符

我认为，这里还有很大的改进空间。

编辑：

  1. 用cout <<替换了putchar
  2. 删除时，使用字符串构造函数重复字符
  3. 删除了指针和虚假的分号之前的空格；
  4. 用逗号混合说明，删除括号。
— 罗伯特·安泽祖克
source
C ++ 11不支持auto作为返回类型，这是C ++ 14的功能。但是，您可以通过设置return type 来解决此问题并保存一个字节int。但是，似乎此代码无效。您可以在“ 在线试用”上对其进行测试！看看你能不能解决？
— musicman523
更改了返回类型auto-> void。我正在Visual Studio 2017上进行测试-自动C ++ 14。添加了gcc版本。
— 罗伯特·安德鲁杰克
哦，好，知道了 我正在运行Linux，所以没有VS。不错的工作！
— musicman523
嗨，罗伯特-您的行程编码方法与我的相似；看这里。我另外将每对（length，char）对打包成一个char而不是2。有7种可能的字符和8种不同的长度；所以我使用56个字符 ' '..'X'进行编码；这样可以节省40个字节，并有一点额外的解码开销。
— Chas Brown
3

R16K1S60大会，152个 144字节

用ASCII将输出写入R16K1S60的屏幕外围设备。在粉玩具保存上运行2012356。（有关信息，请参见标题中的链接）

程序的字节大小是编译结果（使用的单元数* 2），而不是程序集。

您知道徽标占用的空间比字节码更多时，您做得很好。

a:
mov ex, ip
mov ax, .string
mov sp, ip
mov dx, 0x1000
send sp, dx
.loop:
mov bx, [ax]
cmp bx, ip
je .end
cmp bx, ip
je .newline

shr bx, cx, 8
and cx, 0x00FF
.inner:
send sp, cx
sub bx, ex
jnz .inner
.reentry:
add ax, ex
jmp .loop
.newline:
add dx, 0x0020
send sp, dx
jmp .reentry
.string:
dw 0x0120
dw 0x135F
dw 0x000C
dw 0x012F
dw 0x1320
dw 0x015C
dw 0x000C
dw 0x152D
dw 0x000C
dw 0x017C
dw 0x1320
dw 0x017C
dw 0x000C
dw 0x152D
dw 0x000C
dw 0x017C
dw 0x1320
dw 0x017C
dw 0x000C
dw 0x152D
dw 0x000C
dw 0x015C
dw 0x0A5F
dw 0x0420
dw 0x055F
dw 0x012F
dw 0x000C
dw 0x0B20
dw 0x017C
dw 0x0220
dw 0x012F
dw 0x000C
dw 0x0B20
dw 0x017C
dw 0x0120
dw 0x012F
dw 0x000C
dw 0x0B20
dw 0x017C
dw 0x012F
dw 0x0009
.end:
hlt

说明

上面的汇编代码实现了一种简单的压缩算法，其中单词0x000C是换行符，而0x0009是停止执行的命令。

其他单词则简单地编码，如下所示：0xTTCC

  • T：重复值的次数

  • C：要打印的ASCII字符

ASM使用所有可用的寄存器，包括一些不常用的寄存器：

  • 指令指针，用于获取一些已知值以快速调用以节省一些字节（指令中的常量值不仅是寄存器，还使用一个额外的字节来存储它）

  • 堆栈指针用作第六个通用寄存器，因为没有代码使用堆栈。

实际上，只有AX，BX，CX和DX用于重要数据。EX和SP用于存储一些经常使用的常量。

这有点简单，获胜的机会很小，但是写起来很有趣！

查看旧版本的修订历史记录（就ASM而言，它也是如此）

funfact：如果以字为单位（对于R16K1S60为16位），它将小于pyth答案，为72个字节

— moonheart08
source
2

Mathematica，163个字节

Row@Map[Column,Characters/@{" /-|-|-\\   ",r="_ - - -_   ",r,r,r,r,r,r,r,r,r,"_ - - - |||","_ - - -   /","_ - - -  / ","_ - - - /  ",r,r,r,r,r," \\-|-|-/   "},{1}]
— J42161217
source
2

Python 2，171字节

p,u,q,v,r,s,F=' ','_','/','|','-'*21,'\\',lambda f,m:f+m*19+f;B=lambda n:p*11+v+p*n+q
print'\n'.join([F(p,u),q+p*19+s,r,F(v,p),r,F(v,p),r,s+u*10+p*4+u*5+q,B(2),B(1),B(0)])

每行正好是85个字节！哎呀！

— 丹尼尔
source
2

Zsh，244个字节

这是专门为Zsh（而不是Bash）编写的，因为它允许使用更多奇怪的语法。

alias p=printf
function r { p "$1%.s" {0..$2}}
function l { p $1;r $2 19;p $3;p "\n"}
l " " _ " "
l / " " \\
l - - -
l \| " " \|
l - - -
l \| " " \|
l - - -
p \\
r _ 10
r " " 4
r _ 5
p "/\n"
r " " 11
p "|  /\n"
r " " 11
p "| /\n"
r " " 11
p \|/

注意：当我尝试在tio.run上运行它时，输出与在终端上不同。解决此问题的方法是更换

function r { p "$1%.s" {0..$2}}

与

function r { p "$1%.0s" {0..$2}}

这将使其成为245个字节（link）。

编辑 好像我太急于按下该发布按钮，并且错过了一些空格，这使我的解决方案效率降低了一些。我的新输出似乎关闭了，但是我认为我计算正确了（但是无论如何它都不会改变长度）。

— 路卡·蝎子
source
欢迎来到PPCG！请注意，下划线的下划线中间有四个空格，这在代码输出中丢失了。
— Steadybox '17
@Steadybox哦，愚蠢的我。我已经更新了答案，感谢您指出！
— Luca_Scorpion
没问题！不幸的是，我认为它仍然是一个有点过，但是这个应该修复它（和它也为您节省了字节！）。
— Steadybox '17
我认为您可以使用“ funcname（）{}”代替“ function funcname {}”来节省一些字节
— Winny
2

Python 2中，159个 153 139字节

s=" "*19;e="-"*21;a=" "*9;print" %s\n/%s\\\n%s\n|%s|\n%s\n|%s|\n%s\n\%s    %s/\n%s|  /\n%s| /\n%s|/"%("_"*19,s,e,s,e,s,e,"_"*8,"_"*7,a,a,a)

在线尝试！

编辑：通过使用%格式而不是节省了6个字节.format()。
编辑：感谢musicman523，通过修复输出保存了另外14个字节。

— 歌词
source
1
这不是打印确切的文本（存在额外的行）。解决此问题可能还会节省一些字节。
— Officialaimm'7
这是一个固定的版本，以139字节的高字节
— 传入
1

JavaScript（ES6），151个字节

_=>` 2_________
/0\\
1
|0|
1
|0|
1
\\2    _____/
3|  /
3| /
3|/`.replace(/\d/g,a=>a.repeat.call(...[[" ",19],["-",21],["_",10],[" ",11]][a]))

测试片段

f=
_=>` 2_________
/0\\
1
|0|
1
|0|
1
\\2    _____/
3|  /
3| /
3|/`.replace(/\d/g,a=>a.repeat.call(...[[" ",19],["-",21],["_",10],[" ",11]][a]))

O.innerHTML=f()
<pre id=O>
展开摘要

— 贾斯汀·马里纳（Justin Mariner）
source
1

木炭，48字节

↙¹→Ｐ¹¹↓↓¹Ｐ¹¹‖Ｂ↓¦↘→×¹⁰_Ｍ⁷↑←←×¹⁰_‖ＢＪ¹¹¦⁶→×⁴ ↙↙³↑↑³

在线尝试！

内部结构与Carlos有所不同，尽管起初并不可见。

— 暴民埃里克
source
1

,,,，115个 101 98 字节

我为我能做到的最好而感到absolutely愧。>。>

"|/
"' 11×:"| /
"⇆:"|  /
"⇆'
'/'_5×' 4×'_10×92c'
'|' 19×'|'
'-21×+++++3×110⇆⊣"\
"' 19×'/'
'_19×' #
— 全人类
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.