显示“复活节快乐！”

11

您的任务是打印以下ASCII Art：

 _     _                            _______                           _ 
| |   | |                          (_______)          _              | |
| |__ | | ____ ____  ____  _   _    _____   ____  ___| |_  ____  ____| |
|  __)| |/ _  |  _ \|  _ \| | | |  |  ___) / _  |/___)  _)/ _  )/ ___)_|
| |   | ( ( | | | | | | | | |_| |  | |____( ( | |___ | |_( (/ /| |    _ 
|_|   |_|\_||_| ||_/| ||_/ \__  |  |_______)_||_(___/ \___)____)_|   |_|
              |_|   |_|   (____/

请记住，这是code-golf，因此，字节数最少的代码将获胜。祝好运。

code-golf  string  kolmogorov-complexity 
— 倪
source
2
@FryAmTheEggman这与假定的重复Rickroll有很大不同。仅使用了几个符号：|()/\_这导致完全不同的压缩形式。以前我们也遇到过类似的ASCII艺术挑战，但我希望看到这个问题来看看是否有人利用了几何图形。另一方面，它并不是非常出色，并且您是对的，我们不需要复活节标记。
— 水平河
1
@FryAmTheEggman到的最佳解决方案的Kolmogorov复杂度取决于重上的输出的结构。这不是文本，所以不是骗子。
— lirtosiast
7
@lirtosiast有限的字符集可能很重要，但是我觉得这几乎肯定会由与基于文本的问题相同的技术所主导。毕竟，这只是我的意见，社区可以决定执行哪些观点。
— FryAmTheEggman
4
— 蓝色
1
这是不同的，因为没有输入，因此没有必要进行输入和分析。
— thepiercingarrow '16

Answers:

10

Bubblegum，130个字节

0000000: 758f b579 0530 18c4 7a4f a1d2 7fe5 8102  u..y.0..zO......
0000010: 5ae4 760f 5de8 91ee b3cc 8400 f523 2c3c  Z.v.]........#,<
0000020: 4656 0850 3f60 5b86 5fe4 8290 15a2 84a0  FV.P?`[._.......
0000030: 5a61 4d0b b64f 2b35 c476 eb1e 844e c841  ZaM..O+5.v...N.A
0000040: 08c8 731d 1a02 ead0 1547 1d70 beba 9fd6  ..s......G.p....
0000050: 31bf 5fdb 6c72 1d7b 1051 ed8a a884 7c76  1._.lr.{.Q....|v
0000060: 0fa7 db91 1503 c43c 9b18 124f cdb3 4220  .......<...O..B 
0000070: 9631 716b a71c 3bd6 ed8b 0b62 7ebd 55cf  .1qk..;....b~.U.
0000080: 7a07                                     z.

在线尝试。

使用压缩zopfli --deflate --i10000。

— 意大利面
source
这不是588个字节吗？
— thepiercingarrow
15
@MarkWright quartata发布的是实际代码的
— 十六进制转储
10

JavaScript（ES6），377 373 360 359 345字节

感谢@Neil节省了一个字节，感谢@ edc65节省了14个字节！

想通了，我会试一试。压缩文本中的常见重复模式。

_____ （5个下划线）存储为 _5

      （5个空格）存储为  5

 | | | | |（ |模式的5 ）存储为~5


console.log(` _ 5_ 28_7 27_
|~ 2~2 26(_7) 10_ 13~2
|~_2~2 _4 _4 2_4 2_ 3_ 4_5 3_4 2_3|~_ 2_4 2_4|~
| 2_2)|~/ _ ~ 2_ \\| 2_ \\|~3 ~ 2_3) / _ ~/_3) 2_)/ _ 2)/ _3)_|
|~ 2~ ( (~9_|~ ~2_4( (~2_3~2_( (/ /|~ 4_
|_| 2~_|\\_|2_|~|_/|~|_/ \\_2 ~ ~_7)_|2_(_3/ \\_3)_4)_| 2~_|
 13~_| 2~_| 3(_4/`.replace(/(.)(\d+)/g,(_,a,b)=>a.repeat(b)).replace(/~/g,' |'))
— 吉里奇
source
注意ES6 =>。
— CalculatorFeline
似乎字节可以通过RLEing保存_。
— CalculatorFeline
@CatsAreFluffy这是什么意思？它压缩的运行_与_之后有多少在运行
— jrich
糟糕，我仍使用377字节版本。
— CalculatorFeline
~1或_2几乎不值得。（为什么不使用|2示例？）
— 尼尔
8

BinaryFuck，565378字节

这基本上存储了数组中使用的字符，然后在数组中导航并相应地打印它们。目前比较长，会缩短它的时间。

1000010000000000000000110011110001010010000011011111010010110001011011000000010010111011001111011110010010010000010000010000000000000010000010000000000010000010000000000011011011011011011011011011001111010010000000000110001010000000000000000010000000000011011111010010001010001001001001010010001010000000000000000000000000000010001001001001010000000000000000000000000000000011011011011100010100011100100100100100010100011100100100100100100100100100100100100100100100100100100100100100100100100100100100100010100100100100100100100011100100100100100100100100100100100100100100100100100100100100100100100100100100100010100011100010010010010100011011011011011100010100011100010100100100011100010100011100010100100100100100100100100100100100100100100100100100100100100100100100100100100011011100010010010100100100100100100100010100011011100100100100100100100100100100010100011100100100100100100100100100100100100100100011100010100011100010010010010010100011011011011011100010100011100010010100100011100011100010100011100010100010100100100100011100010100100100100011100100010100100100100011100100010100011100100100010100011100100100100010100100100100100011100100100010100100100100011100100010100100100011011100010100011100010010100011100100010100100100100011100100010100100100100011011100010100011100010010010010010100011011011011011100010100100010100100010100011011011100010100011100011011100010010010100010100011100100011100010100100010100011100010010010100011011011011100010100100010100011100010010010100011011011011100010100011100010100011100010100011100010100100011100010100100010100100100010100011011100011011011100010010010100010100011100100011100011011100010010010010100100100010100011011100100010100010100011011011011011100010010010100010100011100100010010100011011011011011100010010010100010100100100010100011100011011100010010010010010100011011011011011100010100011100010100100100011100010100011011100010010100011011100010010100011100010100011100010100011100010100011100010100011100010100011100010100011100010100011100010100011100010010100011011100010100011100010100100011100010100011100010010100100100100011011011100010010100011011100010010100011100010100011100010010100100100011100011100010100011100010010100011011011100010010100011011100011100010010010100011011011100010010100010100011100010100100100100010100011100010010010010100011011011011011100010010100011011100010100100100011100010010100011011100010010010010100011011100011011100100010010100011011100010100011100100010010100011011011011100010010100010100011100100010010100011011011011100010010010100010010010100011011100100011100100011100010100100011100010010100100100100100100100010100011100011011100100010010100011011011100010010010100100100011011011011100010010010100010010010100011011100100100010100011100100100100010100011100011011100010100100100011100010010100011011100010010010010010100011011011011100100100100100100100100100100100100100100011100010010100011011100010100100100011100010010100011011100010100100100011011100010010010100100100100011011011011100

这是未启动的代码：

+>+++++[<[->>+<<]>>[-<<++>>]<-]<
[>>>+>+>++++>+>+++>+>+++<<<<<<<<<-]
>>+++[->+++++>+++<<]>>->---->>->+++++++++>---->++++++++++
<<<<.>.<.....>.<............................>.......<...........................>.<.>>>>.<<<<<.>.<.>...<.>.<.>..........................<<.>>>.......>.<<..........>.<..............<.>.<.>>>>>.<<<<<.>.<.>>..<.<.>.<.>.>....<.>....<..>....<..>.<...>.<....>.....<...>....<..>...<<.>.<.>>.<..>....<..>....<<.>.<.>>>>>.<<<<<.>..>..>.<<<.>.<.<<.>>>.>.<..<.>..>.<.>>>.<<<<.>..>.<.>>>.<<<<.>.<.>.<.>.<.>..<.>..>...>.<<.<<<.>>>.>.<..<.<<.>>>>...>.<<..>.>.<<<<<.>>>.>.<..>>.<<<<<.>>>.>...>.<.<<.>>>>>.<<<<<.>.<.>...<.>.<<.>>.<<.>>.<.>.<.>.<.>.<.>.<.>.<.>.<.>.<.>.<.>>.<<.>.<.>..<.>.<.>>....<<<.>>.<<.>>.<.>.<.>>...<.<.>.<.>>.<<<.>>.<<.<.>>>.<<<.>>.>.<.>....>.<.>>>>.<<<<<.>>.<<.>...<.>>.<<.>>>>.<<.<<..>>.<<.>.<..>>.<<<<.>>.>.<..>>.<<<<.>>>.>>>.<<..<..<.>..<.>>.......>.<.<<..>>.<<<.>>>...<<<<.>>>.>>>.<<...>.<....>.<.<<.>...<.>>.<<.>>>>>.<<<<..............<.>>.<<.>...<.>>.<<.>...<<.>>>....<<<<.

编辑：通过重新排列单元格中字符的顺序，我节省了186个字节！

— 穿刺箭
source
8
这不是字节计数的工作方式。如果您无法将字节的确切顺序传递给解释器，则无法声明该字节数作为字节数。
— 门把手
1
如果有是一个BF-解释这需要在3比特/字符。如果您要声明565个字节，请添加指向解释器的链接和已编码代码的十六进制转储/粘贴框。
— Downgoat
2
是的，有一个3位的Brainfuck解释器。在答案中添加与此链接以及代码的十六进制转储/二进制表示。该语言不再令人费解，因此您必须在标题中指定“ CompressedFuck”。我建议保持原样，就像看到脑残的人不希望它太短一样。
— Downgoat
1
这看起来不像有效的BinaryFuck程序；它不是以开头的1。请提供指向解释器和源代码十六进制转储的链接，以便可以复制您的结果。
— 丹尼斯
2
如果要按照Binaryfuck的要求在每个指令中声明3位，则需要发布Binaryfuck源代码（可能在十六进制转储中或以base64编码），然后据此计算字节。就目前而言，此提交是一个令人难以置信的提交，具有1012个字节，其中3个是多余的（换行符）。
— Mego
6

JavaScript（ES6），380个字节

为了完整起见，这是我使用另一种压缩方法的努力，尽管事实证明它不如游程长度编码有效。每个数字指定重复最近的N个已经生成的字符。随后的数字可以重复已经重复的字符，例如| 23变成| | |。我只希望可以压缩三个字符。

f=(s=` _  26  2479__23   2499_ 
| 2  6  2379(__23)   25_  237|2
| |__ |2 __25  __2  _ 4   ___2   __2  ___| |_  ___6_| |
|  __)| |/ _  |  _ \\6| 24 |  ___) / _  |/___)  _)/ _  )/ ___)_|
| 2  | (2 |248 |_| 23|__2( 2| |___ |2_( (/ /| 2   _ 
|_|   |_|\\_||_| ||_/6 \\__  |3__23)_||_(___/ \\___)_5|   |_|
  237|_|6   (__2/`,r=s.replace(/(.*?)(\d)/,(_,p,n)=>p+p.slice(-n)))=>r==s?r:f(r)

o.textContent = f()
<pre id=o></pre>
展开摘要

— 尼尔
source
6

C，517个 427 407字节

  • 节省了几个字节，这要归功于@ceilingcat
c,i;main(m){for(char*s=" _ 4_ 999_6 998_ 1\n|B 2|B 997(_6) 9_ 94|B \n| |_1C _3 _3 1_3 1_ 2_ 3_4 2_3 1_2|B_ 1_3 1_3|B \n| 1_1)|B/ _ 1\\| 1_ \\| 1_E 1| 1_2) / _ 1|/_2) 1_)/ _ 1)/ _2)_| \n|B 2| ( (J_|B 1|B_3( (C_2C_( (/ /|B 3_ 1\n|_| 2|_|\\_||_|B1_/|B1_/ \\_1 1| 1|_6)_|1_(_2/ \\_2)_3)_| 2|_| \n 94|_| 2|_| 2(_3/\n";*s;s++)for(i=isdigit(*s)?c=m,*s-48:isalpha(*s)?c=0,*s-65:(c=*s,1);i--;)printf(c?m=c,&c:" |");}

脱线 尝试在线

#include <stdio.h>
#include <stdint.h>

char m = 0;

void g(char c, int i)
{
    while(i--) c ? m=putchar(c) : printf(" |");
}

void p(char* s)
{
    while(*s)
        isdigit(*s) // golfed if-else-if
        ? g(m,*s-48)
        : isalpha(*s)
          ? g(0,*s-65)
          : g(*s,1)
        ,
        s++;
}

int main()
{
    p(" _ 4_ 999_6 998_ 1\n|B 2|B 997(_6) 9_ 94|B \n| |_1C _3 _3 1_3 1_ 2_ 3_4 2_3 1_2|B_ 1_3 1_3|B \n| 1_1)|B/ _ 1\\| 1_ \\| 1_E 1| 1_2) / _ 1|/_2) 1_)/ _ 1)/ _2)_| \n|B 2| ( (J_|B 1|B_3( (C_2C_( (/ /|B 3_ 1\n|_| 2|_|\\_||_|B1_/|B1_/ \\_1 1| 1|_6)_|1_(_2/ \\_2)_3)_| 2|_| \n 94|_| 2|_| 2(_3/\n");
    return 0;
}
— 哈立德
source
5

JavaScript，297字节

console.log(` 29 288999002889 3 
19 18899 500_)82891
1__ 1 0_ 02022 290_2 02012020_1
|3_)162|3 \\|3 \\1 19|90) 62|/0)3)62)60)_|
19 |55 1 1 1 1 71910_(5 10 1_(56/193 
7|4\\_|717/176\\_2|9|00_)_|7(06\\0)0_)_|4
8 44950_/`.replace(/\d/g,n=>`___,| |,_  ,  _,   |_|, (,/ ,|_,          ,  `.split`,`[n]))

对十个（据我所知）常见子字符串的简单编码。由于重叠，它们不整齐。我的编码器（下方）需要查看例如'_ '和' _'之前' '。

(s,a,t=s)=>a.map((t,i)=>s=s.split(t).join(i))&&[s,(b=>{b=new Map;for(i=0;i<s.length;i++)for(j=0;j<i;j++)b.set(s.slice(j,i),s.length-s.split(s.slice(j,i)).join().length-i+j-1);return[for(x of b)if(x[1]>0&&!/\d/.test(x[0]))x].sort(([a,b],[c,d])=>b-d)})(),t.length-(s+' '+a).length]

这需要一个字符串和一个子字符串数组进行编码，并返回a）编码后的字符串b）可能的下一个节省列表c）到目前为止保存的字节数。

— 尼尔
source
5

𝔼𝕊𝕄𝕚𝕟，72个字符/ 209个字节

`Эć훼쎧漤詼媰਀㻆僚픈耊Ⓢኍ⋱쬝ᇑ덆䖇䂊՛樥첾㨭쯠ཁ톇:덱螟醮䖉⥊覂削ꇉ漈涹႘챘ඕ꼳⁒᭷Ừ䒕鶀놜㆝〢ﱱꎀ쎴䋈㗂䅉Ⴄቀ쳵菨ⶩ∉툲耀

Try it here (Firefox only).

好吧，至少字符数很棒，但是我们不能使用自定义代码页。这只是一个LZString解压缩。我还在研究另一个解决方案-稍后再讨论。

— 妈妈趣味卷
source
5

Perl 5，286字节

perl -M5.01 happy.pl，在哪里happy.pl：

$_='u5u28 7_27u
~~x~~25 (7_)10u7x~~
~p_ ~~4_ 4_x4_x_3u4 5_3 4_x3_~px4_x4_~~
~u_)~|/ux~u \~u \4~ ~ 3_) /ux|/3_)x_)/ux)/ 3_)_|
~~x~( ( 8~p~~ ~|4-( ( ~p__ ~p( (/ /~~3u
p~xp|\_|p~|p/~|p/ \__x~ p6_)_|p(3_/ \3_)4_)_~xp|
14 p~xp~x(4_/';s/u/ _/g;s/\d+(.)/$1x$&/ge;s/x/  /g;s/~/| /g;s/p/|_/g;say

感谢Dom Hastings（在本文的评论中）提出的一个想法为我节省了两个字节，并导致我的另一个想法又节省了四个字节。

— msh210
source
当然，您应该将L其用作|_;-) 的速记
— Neil
3

Python 2中，343个 328 316字节

此解决方案不使用任何解压缩功能或其他导入。

o=""
for i in range(250):j=ord(")*I*yyQZyyI*(!+9!+yyA,Z-q*y9!+(!+2)!!B)B1B1*9*AJ9B1:!+*1B1B!+(+12-!+/)*1+1*).+1*).!!!+1+1:-)/)*1+/:-1*-/)*1-/):-*+(!+9!,),)!!!!!!!!+*!+1!+B,),)!+:)!+*,),/)/!+A*(+*+9+*+.*3*!3*/!3*/).21+1+Z-*3*,:/).:-B-*+9+*+(y9+*+9+*+9,B/(".replace("!","+)")[i])-40;o+="\n _|()\/"[j&7]*(j/8+1)
print o

可读版本：

DATA=(")*I*yyQZyyI*("
"!+9!+yyA,Z-q*y9!+("
"!+2)!!B)B1B1*9*AJ9B1:!+*1B1B!+("
"+12-!+/)*1+1*).+1*).!!!+1+1:-)/)*1+/:-1*-/)*1-/):-*+("
"!+9!,),)!!!!!!!!+*!+1!+B,),)!+:)!+*,),/)/!+A*("
"+*+9+*+.*3*!3*/!3*/).21+1+Z-*3*,:/).:-B-*+9+*+("
"y9+*+9+*+9,B/(").replace("!","+)")
SIZE=250
o=""
for i in range(SIZE):
 j=ord(DATA[i])-40
 o+="\n _|()\/"[j&7]*(j/8+1)
print o

对来自“ \ n _ |（）/”集中的符号使用3位游程编码的版本。字节的其余部分是长度，但是我将长度限制为10并对其进行了处理，以便结果是可打印的字符，这些字符在python字符串中有效，没有任何转义。

在编码数据中用单个字符替换与“ |”相对应的字符串可以节省更多的字节。

我删除了第1行和第5行的尾部空格，这可能会使规则有些弯曲，但似乎很实际。

该程序生成打包数据：

message="""
 _     _                            _______                           _
| |   | |                          (_______)          _              | |
| |__ | | ____ ____  ____  _   _    _____   ____  ___| |_  ____  ____| |
|  __)| |/ _  |  _ \|  _ \| | | |  |  ___) / _  |/___)  _)/ _  )/ ___)_|
| |   | ( ( | | | | | | | | |_| |  | |____( ( | |___ | |_( (/ /| |    _
|_|   |_|\_||_| ||_/| ||_/ \__  |  |_______)_||_(___/ \___)____)_|   |_|
              |_|   |_|   (____/"""[1:]
size=len(message)
symbols="\n _|()\/"
i=0
encoded=""
while i<size:
    count=0
    while count<10 and i+count+1<size and message[i+count+1]==message[i]:
        count+=1
    n = symbols.find(message[i]) | count<<3
    encoded+=chr(n+40)
    i+=count+1
encoded_lines = encoded.replace("+)","!").split(chr(40))
for line in encoded_lines:
    print line+chr(40)
print len(encoded)
— 查克·莫里斯（Chuck Morris）
source
您好，欢迎来到PPCG！很棒的帖子！
— NoOneIsHere
@NoOneWasLiterallyEverHereEver不是说这是他们的第一篇文章或任何东西，但肯定:)
— 猫
2

Python 2，159字节

此来源包含不可打印的字符，因此以十六进制转储形式显示，可以使用进行解码xxd -r。

00000000: efbb bf70 7269 6e74 2278 017d 8fb5 7540  ...print"x.}..u@
00000010: 3114 c5fa 3f85 4abb f240 012d a2dd 432f  1...?.J..@.-..C/
00000020: 4cba c732 1302 20ff e0c0 dfc8 1501 e33f  L..2.. ........?
00000030: 580e 9b77 e40b d115 2911 aa23 1c33 05a7  X..w....)..#.3..
00000040: cf54 6ae4 74c7 7310 baa3 8310 c86d 8c27  .Tj.t.s......m.'
00000050: 04ea 6656 9c79 9bfb a5fb 6cdd f6fe b5c5  ..fV.y....l.....
00000060: a2ef 3182 4875 56a4 123d 770f 2702 902b  ..1.HuV..=w.'..+
00000070: 03b2 5bcb 28cf 985b 8520 876d b974 a6dc  ..[.(..[. .m.t..
00000080: be28 20bb f842 f6ee a57a 1e01 c1a2 733e  .( ..B...z....s>
00000090: 222e 6465 636f 6465 2827 7a69 7027 29    ".decode('zip')
— 安德斯·卡塞格（Anders Kaseorg）
source
2

球拍，367364字节

(require file/gunzip net/base64)((λ(o)(gunzip-through-ports(open-input-bytes(base64-decode #"H4sIAOhN/lYAA31QwQ3EMAj7dwqezYuFInkRhj+MoWor9UBCmGBDMBhN8cMg+9dhR1hkovhhZwutO/FhSadQzqJQDdXkjsOYfa5Hkm4QEsp0ZeYkEdmeKK8i91GHazesgoyJEdfXzvR4O1ooOLY7oA8QunnfhDdCCSE2oogBV7QN7RhzI3bwYPWUUDXRj9fVpj439h/OlCKU1gEAAA=="))o)(displayln(get-output-string o)))(open-output-bytes))

不打高尔夫球

(require file/gunzip net/base64)
((λ (o)
   (gunzip-through-ports
    (open-input-bytes
     (base64-decode
      #"H4sIAOhN/lYAA31QwQ3EMAj7dwqezYuFInkRhj+MoWor9UBCmGBDMBhN8cMg+9dhR1hkovhhZwutO/FhSadQzqJQDdXkjsOYfa5Hkm4QEsp0ZeYkEdmeKK8i91GHazesgoyJEdfXzvR4O1ooOLY7oA8QunnfhDdCCSE2oogBV7QN7RhzI3bwYPWUUDXRj9fVpj439h/OlCKU1gEAAA=="))
    o)
   (displayln (get-output-string o)))
 (open-output-bytes))

基于类似的挑战，我回答了。

— 温尼
source
2

///，282279字节

改进：我注意到//替换命令太多了，所以我决定也将它们压缩到（to m），这节省了我3个字节。

/m/\/\///l/ _mk/|amj/b_mi/\\\m/h/|cmg/ddmf/ccme/bbmd/aamc/ |mb/__ma/  /ldlgggdejgggal 
hafggga(ej)ga_gdah
hbf e eaea_alde_a eajh_aeaeh
kb)hilak_ \\k_ \\|fcakj) ila|ij)a_)ila)i j)_|
hac ( (ffffc_hahe( (fjf_( (i ihd_ 
|_kc_|\\_||_h|_ih|_i \\bak|ej)_||_(ji \\j)e)_kc_|
gda|_kc_k (ei

重复压缩最频繁的子字符串。

第十三代，282字节

/l/ _//k/|a//j/b_//i/\\\///h/|c//g/dd//f/cc//e/bb//d/aa//c/ |//b/__//a/  /ldlgggdejgggal 
hafggga(ej)ga_gdah
hbf e eaea_alde_a eajh_aeaeh
kb)hilak_ \\k_ \\|fcakj) ila|ij)a_)ila)i j)_|
hac ( (ffffc_hahe( (fjf_( (i ihd_ 
|_kc_|\\_||_h|_ih|_i \\bak|ej)_||_(ji \\j)e)_kc_|
gda|_kc_k (ei

在线尝试！

第一代，486字节

无压缩。转义了/和\。

 _     _                            _______                           _ 
| |   | |                          (_______)          _              | |
| |__ | | ____ ____  ____  _   _    _____   ____  ___| |_  ____  ____| |
|  __)| |\/ _  |  _ \\|  _ \\| | | |  |  ___) \/ _  |\/___)  _)\/ _  )\/ ___)_|
| |   | ( ( | | | | | | | | |_| |  | |____( ( | |___ | |_( (\/ \/| |    _ 
|_|   |_|\\_||_| ||_\/| ||_\/ \\__  |  |_______)_||_(___\/ \\___)____)_|   |_|
              |_|   |_|   (____\/

在线尝试！

第二代，402字节

将两个空间压缩为a。该/a/ /方法“替换所有出现的a两个空间”。

/a/  / _aa _aaaaaaaaaaaaaa_______aaaaaaaaaaaaa _ 
| |a | |aaaaaaaaaaaaa(_______)aaaaa_aaaaaaa| |
| |__ | | ____ ____a____a_a _aa_____a ____a___| |_a____a____| |
|a__)| |\/ _a|a_ \\|a_ \\| | | |a|a___) \/ _a|\/___)a_)\/ _a)\/ ___)_|
| |a | ( ( | | | | | | | | |_| |a| |____( ( | |___ | |_( (\/ \/| |aa_ 
|_|a |_|\\_||_| ||_\/| ||_\/ \\__a|a|_______)_||_(___\/ \\___)____)_|a |_|
aaaaaaa|_|a |_|a (____\/

在线尝试！

第三代，369字节

压缩__为b。在/b/__/一开始的意思是“代替所有出现的b对__”。

/b/__//a/  / _aa _aaaaaaaaaaaaaabbb_aaaaaaaaaaaaa _ 
| |a | |aaaaaaaaaaaaa(bbb_)aaaaa_aaaaaaa| |
| |b | | bb bbabba_a _aabb_a bbab_| |_abbabb| |
|ab)| |\/ _a|a_ \\|a_ \\| | | |a|ab_) \/ _a|\/b_)a_)\/ _a)\/ b_)_|
| |a | ( ( | | | | | | | | |_| |a| |bb( ( | |b_ | |_( (\/ \/| |aa_ 
|_|a |_|\\_||_| ||_\/| ||_\/ \\ba|a|bbb_)_||_(b_\/ \\b_)bb)_|a |_|
aaaaaaa|_|a |_|a (bb\/

在线尝试！

第四代，339字节

压缩 |为c。在/c/ |/一开始的意思是“代替所有出现的c对|”。

/c/ |//b/__//a/  / _aa _aaaaaaaaaaaaaabbb_aaaaaaaaaaaaa _ 
|caccaaaaaaaaaaaaa(bbb_)aaaaa_aaaaaaa|c
|cbcc bb bbabba_a _aabb_a bbab_|c_abbabb|c
|ab)|c\/ _a|a_ \\|a_ \\|ccca|ab_) \/ _a|\/b_)a_)\/ _a)\/ b_)_|
|cac ( (ccccccccc_|ca|cbb( (ccb_cc_( (\/ \/|caa_ 
|_|ac_|\\_||_|c|_\/|c|_\/ \\ba|a|bbb_)_||_(b_\/ \\b_)bb)_|ac_|
aaaaaaa|_|ac_|a (bb\/

在线尝试！

其余的压缩规则

因此，压缩规则列表：

  • 将两个空格压缩为a。
  • 压缩__为b。
  • 压缩 |为c。
  • 压缩aa为d。
  • 压缩bb为e。
  • 压缩cc为f。
  • 压缩dd为g。
  • 压缩|c为h。
  • 压缩\/为i。规则中的\和/都将进一步转义。
  • 压缩b_为j。
  • 压缩|a为k。
  • 压缩 _为l。
  • 压缩//为m。

如您所见，存在重叠的压缩规则。例如，g编码dd哪个编码aaaa哪个编码8个空格。

— 漏尼姑
source
如果您想喝醉但又没有酒精，请尝试发音其中一种。被证明可以在父母身上工作
— 2016年
2

您的妈妈（无竞争），331个字节

解码字符串并使用Jelly压缩器将其解压缩

'IF8KfCgpL1z/AQAAAQAAAAAAAAAAAAAAAAAAEREREAAAAAAAAAAAAAAAAAAQIwMAAwMAAAAAAAAAAAAAAAAAQREREVAAAAAAAQAAAAAAAAAwMjAxEDAwEREBERABERABAAEAABEREAAREQAREwMQAREQARETAyMAEVMDYBADABBzABBzAwMDADABEVBgEANhEVABVgEAVgERUTIwMAAwQEAwMDAwMDAwMDEwMAMDERFAQDAxEQMDFARgYwMAABAjEwADE3EzEwMxYwMxYHEQAwAxERERUTMUERYHERUREVEwADEyAAAAAAAAADEwADEwAEERFg=='`
— Tux工艺
source
您如何在我妈妈中竞争？！？！几个月前注册关闭……
— Magic Octopus Urn
1

Python 3，377个字节

from re import*;i=0
r=r'2_.7_./ .|2.| .4_.\\. _._d|.( (.3_). _ .2|_. |2 ._| |.a| |./ _2 .|3 |_. 4_2 . | |.\n'
e='an5n28 t27jf3b26 (t)10n14bfub pcp2n3n4 5_3c3g_2c4gar u)q|erjorjo|bhr k e|/k2n)e)sk_|f3 qlbbbb |g2bplb3_b_ls/q|4ja|mo_iqi/qisou2h|t)_i(3_sokp)ma14 |m3 (p/'
for j in r.split('.'):e=sub(chr(117-i),j,e);i+=1
print(sub('(\d+)(.)',lambda x:int(x.group(1))*x.group(2),e))

与javascript答案类似，它使用RLE加上一堆普通子字符串的替代物。

认为我在替换方面有点过头了，可能没有太大帮助，但是很好。

— mtp
source
1

JavaScript（ES6），354字节

另一个尝试。不幸的是，效率不如运行时间长。

i=0,console.log(`1c1bt96zfx1!1n4ikabr1w5!1n4iut4kyue!krgqthnkpkem8!43tb4j2urme!8hwrsagny80!69dfowb7hvk!2xj89rpvcb2!23l14ken5i1!1xzn6ns7j78!1tzyivgb4h2!1yy885vts00!12du7km7f51!1lvpcyzgbfq!17nicizf8og0!1246xqebgb9!1n4j181hywz!`.replace(/\w+!/g,v=>parseInt(v,36).toString(4).replace(/./g,w=>"_ |"[w]||`
()

)/\\\\)//))/)/)
((((((//
\\//\\)(/\\))
(/`[i++])))

在第一个字符串中存储一堆以36为基数的数字，并用分隔符!分隔。然后用!数字的base-4表示形式替换数字（以及）。取代所有的0的，1'S，2名在基数4与_， ，和|分别与所有3块的被替换顺序第二串中的元素。

— 吉里奇
source
1

Python 3，263个字节

使用内建函数的初始阶段。

from base64 import*
from zlib import*
print(decompress(a85decode(b"Gas1Y_%\"=:#lAfQT$<1I,'acT5E):N/+l.oQs`98(esP<+T'c!7p'"
b";rpgIeCXZQ&]8Z,D1U/2<LjGq-FIBH)'D@dH'FCjS[&_Wa(Y9N^<LMJiMJrGNuf@S=?GWT(W34:oA%hQ<"
b"thh3pT#pD4$L]LSa%IG!R,BiQaoor91d>uo0VEQs4+2O[m4o")).decode())

添加了一些额外的引号和换行符，以避免水平滚动（仅出于显示目的）（不计入分数）

— 尼克·T
source
6
不用担心水平滚动。只要复制粘贴文本原样，因为这是我们感兴趣的问题。
— El'endia接龙
我知道，我只是想避免这种情况。也可能不做所有的十六进制转储。
— 尼克T
您可以尝试将zlib数据存储在字符串中。您可以避开一些字符，但是可能要短很多。请参阅此答案作为参考。
— 2016年
repr()原始字符串的@agtoever的时间比ascii85长得多
— Nick T
4
@NickT请删除其他引号和空格。您的代码应确保我们可以将其复制/粘贴到字节计数器中，并获得相同的结果。谢谢。如果您想要一个不错的，可显示的版本，请发布一个非高尔夫版本。
— mbomb007 '16
1

果酱，229

"3WPPEFXvN'vlFBse/cTD>.x:Na,Y&NJH^tZ%xL(NkYzo0Rq%BeV&Zl1T^2y69,W/QC4pL`nv<Jo$'Cq.'m2-3H#9teHi&<uyO>f V)D\E y'*]oGq*ODjQLyoS*GyM7;\Z.n6B;J@OyEaE!4'E5p5MOl^#[,ZtA;`jy,gTP^\;;i<A6^:k1%"' fm91b31b"}*+{~'NHIF\JLM
OGQK)(P/RST|_- \""f=~

没有时髦的字符，没有内置的压缩​​:)

在线尝试

— aidtsu退出，因为SE是邪恶的
source
1

Lua，353个字节

程序：

a=(" _ 5_ 28_7 27_\n|~ 2~2 26(_7) 10_ 13~2\n|~_2~2 _4 _4 2_4 2_ 3_ 4_5 3_4 2_3|~_ 2_4 2_4|~\n| 2_2)|~/ _ ~ 2_ \\| 2_ \\|~3 ~ 2_3) / _ ~/_3) 2_)/ _ 2)/ _3)_|\n|~ 2~ ( (~9_|~ ~2_4( (~2_3~2_( (/ /|~ 4_\n|_| 2~_|\\_|2_|~|_/|~|_/ \\_2 ~ ~_7)_|2_(_3/ \\_3)_4)_| 2~_|\n 13~_| 2~_| 3(_4/"):gsub("(.)(%d+)",function(a,b)return a:rep(b)end):gsub("~"," |")print(a)

感谢@jrich进行压缩。

— 漏尼姑
source
1

红宝石，271个 262 248字节

require'zlib'
require'base64'
puts Zlib.inflate Base64.decode64'eJx1UMENxDAI+zMFz+bFQpG8CMMX46DeVWpQrJjYhGDp6e7Cj3VBaz0p/CvKbrWBLkStYHAcEH8uafqhUKE6rjoFTWS+BxWdZD9ShHrDakosju6oe7sq8h04hZLPHgX0AdLwODOBG8VOy0a2MRFC31CPOTOiggPrq6LKyW6vqU1+Zhx2A7NMZ9I'

在这里尝试

— 纳尔科兹
source
1

VIM，374次 365 326 319 313 311击键

感谢@Dr Green Eggs和Ham DJ 9次击键。

:im @ ___<CR>
:im % _|<CR>
a _## _<esc>28a <esc>yl7a_<esc>27pa_ <CR>
|!#!!<esc>26pa(<esc>7a_<esc>a)<esc>10pa_<esc>14pa|!<CR>
|!__!!<esc>3a @_<esc>bi <esc>A#_# _##@__# @_#@|!_#@_#@%!<CR>
|#__)|!/ _ !#_ \|#_ \<esc>4a| <esc>a!#@) / _ !/@)#_)/ _#)/ @)%<CR>
|!#! ( (<esc>9a!<esc>a%! !!@_( (!!@!!_( (/ /|!##_ <CR>
|%#!%\%|_<esc>2a|!|_/<esc>a \__ ! !<esc>7a_<esc>a)%|_(@/ \@)@_)%#!%<CR>
<esc>14pa|%#!%# (@_/<esc>
:%s/!/ |/g<CR>
:%s/#/  /g<CR>

可以通过使用:nn？进一步打高尔夫球？

— 漏尼姑
source
瞥了一眼后，这里有一些快速提示。1.你做<number>a <esc>很多。如果您yl在空格上操作，则可以将其替换为<number>p。那应该节省大约8。2.您可以替换ea为A。如果您改变方法，可能会花费更多，但这是我所看到的快速提示。
— 詹姆斯，
@DrGreenEg​​gsandHamDJ有什么办法，我可以映射一个按键打字_和|等？
— Leaky Nun
我正在打电话，所以无法测试，但我认为这是不正确的。:s仅替换一行。你要:% s。您也可以通过执行:im（imap）而不是搜索和替换来保存一些击键。（尽管您可能需要使用ctrl-v或ctrl-q来映射到空间）
— 詹姆斯
@DrGreenEg​​gsandHamDJ很好，但是:im我想使用只能打更多的字节。
— Leaky Nun
1

Javascript（ES6） 464 352字节

00000000  63 6f 6e 73 6f 6c 65 2e  6c 6f 67 28 60 08 09 28  |console.log(`..(|
00000010  09 c3 a0 39 c3 98 09 08  0f 0c 08 0c 18 0c 08 0c  |...9............|
00000020  c3 90 0a 39 0e 50 09 70  0c 08 0c 0f 0c 08 0c 11  |...9.P.p........|
00000030  08 0c 08 0c 08 21 08 21  10 21 10 09 18 09 20 29  |.....!.!.!.... )|
00000040  18 21 10 19 0c 08 0c 09  10 21 10 21 0c 08 0c 0f  |.!.......!.!....|
00000050  0c 10 11 0e 0c 08 0c 0a  08 09 10 0c 10 09 08 0c  |................|
00000060  10 09 08 0c 08 0c 08 0c  08 0c 10 0c 10 19 0e 08  |................|
00000070  0a 08 09 10 0c 0a 19 0e  10 09 0e 0a 08 09 10 0e  |................|
00000080  0a 08 19 0e 09 0c 0f 0c  08 0c 18 0c 08 0a 08 0a  |................|
00000090  08 0c 08 0c 08 0c 08 0c  08 0c 08 0c 08 0c 08 0c  |................|
000000a0  08 0c 09 0c 08 0c 10 0c  08 0c 21 0a 08 0a 08 0c  |..........!.....|
000000b0  08 0c 19 08 0c 08 0c 09  0a 08 0a 08 0a 0c 08 0c  |................|
000000c0  20 09 08 0f 0c 09 0c 18  0c 09 0c 09 14 09 0c 08  | ...............|
000000d0  14 09 0a 0c 08 14 09 0a  08 11 10 0c 10 0c 39 0e  |..............9.|
000000e0  09 14 09 0a 19 0a 08 19  0e 21 0e 09 0c 18 0c 09  |.........!......|
000000f0  0c 0f 70 0c 09 0c 18 0c  09 0c 18 0a 21 60 2e 73  |..p.........!`.s|
00000100  70 6c 69 74 28 22 22 29  2e 6d 61 70 28 61 3d 3e  |plit("").map(a=>|
00000110  61 2e 63 68 61 72 43 6f  64 65 41 74 28 29 29 2e  |a.charCodeAt()).|
00000120  6d 61 70 28 61 3d 3e 41  72 72 61 79 28 28 61 3e  |map(a=>Array((a>|
00000130  3e 33 29 2b 31 29 2e 6a  6f 69 6e 28 22 20 5f 2f  |>3)+1).join(" _/|
00000140  5c 5c 7c 28 29 5c 6e 22  2e 73 70 6c 69 74 28 22  |\\|()\n".split("|
00000150  22 29 5b 61 26 37 5d 29  29 2e 6a 6f 69 6e 28 22  |")[a&7])).join("|
00000160  22 29 29                                          |"))|

在这里尝试！

1

HTML，482个 481 475字节

<pre> _     _                            _______                           _ 
| |   | |                          (_______)          _              | |
| |__ | | ____ ____  ____  _   _    _____   ____  ___| |_  ____  ____| |
|  __)| |/ _  |  _ \|  _ \| | | |  |  ___) / _  |/___)  _)/ _  )/ ___)_|
| |   | ( ( | | | | | | | | |_| |  | |____( ( | |___ | |_( (/ /| |    _ 
|_|   |_|\_||_| ||_/| ||_/ \__  |  |_______)_||_(___/ \___)____)_|   |_|
              |_|   |_|   (____/
展开摘要

— 用户8397947
source
注意：不能简单地在电话上正确查看此内容。
— user8397947 '16
既然你正在做的这一切，反正，你不需要关闭前标签
— 优化
为什么在第5行上有尾随空格？：P
— Optimizer
1

05AB1E，171 个字节

"_ |0/)(
\"•1æÆ&¢ÙDÿœƒ˜¶f
¹∍[saÎΛÞÀθ¶\‚e–8(¬šôon&{wαλµ.cRŽ1ºWèíÄʒΣ ι.ì¨Gt‰?WиΛÆ—©UãšW#тÊ÷´¥b™¢,V§¯l€éàøjòÐø¬ëäÇ kĀT¬Àн4p«ªÒdαñáyÛƦ‚@ø‘Ñ‚иu₅₂Qp>øî÷^‡иÓ7¯ÓÇŠ@ÄéS•9вèJ0…   :

在线尝试。

说明：

"_ |0/)(
\"            "# Push string "_ |0/)(\n\"
  •1æÆ&¢ÙDÿœƒ˜¶f
  ¹∍[saÎΛÞÀθ¶\‚e–8(¬šôon&{wαλµ.cRŽ1ºWèíÄʒΣ ι.ì¨Gt‰?WиΛÆ—©UãšW#тÊ÷´¥b™¢,V§¯l€éàøjòÐø¬ëäÇ kĀT¬Àн4p«ªÒdαñáyÛƦ‚@ø‘Ñ‚иu₅₂Qp>øî÷^‡иÓ7¯ÓÇŠ@ÄéS•
               # Push compressed integer 1097503083536947704653792841425892054204805659502021445044262296065039856679486956980779201344195600186307613120325421519873972685660197036332437042797892085831181080642513349371962439499848029872306826792254102689695782393365417312419084231420872539225014767457254170199022042856591776594745757160095950475758150232076499909206475280246564765470414367938
   9в          # Converted to Base-8 as list: [1,0,3,1,1,0,3,3,3,3,3,3,3,3,3,1,0,0,0,0,0,0,0,3,3,3,3,3,3,3,3,3,0,7,2,1,2,3,2,1,2,3,3,3,3,3,3,3,3,1,1,6,0,0,0,0,0,0,0,5,3,3,3,1,0,3,3,3,3,1,1,2,1,2,7,2,1,2,0,0,1,2,1,2,1,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,1,0,3,0,3,1,0,0,0,0,0,3,0,0,0,0,1,1,0,0,0,2,1,2,0,1,1,0,0,0,0,1,1,0,0,0,0,2,1,2,7,2,1,1,0,0,5,2,1,2,4,1,0,1,1,2,1,1,0,1,8,2,1,1,0,1,8,2,1,2,1,2,1,2,1,1,2,1,1,0,0,0,5,1,4,1,0,1,1,2,4,0,0,0,5,1,1,0,5,4,1,0,1,1,5,4,1,0,0,0,5,0,2,7,2,1,2,3,2,1,6,1,6,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,0,2,1,2,1,1,2,1,2,0,0,0,0,6,1,6,1,2,1,2,0,0,0,1,2,1,2,0,6,1,6,4,1,4,2,1,2,3,1,0,7,2,0,2,3,2,0,2,8,0,2,2,0,2,1,2,2,0,4,2,1,2,2,0,4,1,8,0,0,1,1,2,1,1,2,0,0,0,0,0,0,0,5,0,2,2,0,6,0,0,0,4,1,8,0,0,0,5,0,0,0,0,5,0,2,3,2,0,2,7,3,3,3,3,1,1,2,0,2,3,2,0,2,3,6,0,0,0,0,4]
     è         # Index each into the string
      J        # Join all characters together to a single string
       0…   :  # Replace all "0" with "   " (3 spaces)
               # (and output the string implicitly as result)

请参阅我的05AB1E技巧（如何压缩大整数？和如何压缩整数列表？），以了解压缩的整数和Base-8列表如何工作。

— 凯文·克鲁伊森
source
我打败你;）。
— 魔术章鱼缸
1
没关系，不，我不是+1。
— 魔术章鱼缸
@MagicOctopusUrn：D
— 凯文·克鲁伊森
1

C（GCC） ，280个 279字节

f(i){for(char*A=" _|/\\()\n",*s="H@@H.@#IA-@AWP@PP-@M#IF$@H'@BzBJABBIIHIAHIAH@H@@IIA@II@IQPAHIAHIQPW@IVPCAP@AT@AT#P@BHIFCAPKIFH^H@^HINzBB@BEE(BJBBPPIIEEBJIPPihCSP@@AWQ@PQLRQPJSPJCLAP@J#INRiIY`IqIINB@Jz'@JB@JB@MIY";i=*s>63?:*s++;s++)for(;i--&31;)printf("%c%c",A[*s&7],A[*s/8&7]);}

在线尝试！

撞倒

我们定义了一个由8个符号组成的字母" _|/\\()\n"，并通过根据字节在字母表中的索引在每个字节中打包两个符号来压缩数据，第一个符号在位0..2，第二个在位3..5。设置位6为将结果字节带入可打印的ASCII区域。然后在压缩的字符串上运行一个简单的RLE。如果字符串中的一个符号连续出现两次以上，则将其存储为一个字符对，第一个包含游程长度加32（设置了位5），第二个包含符号本身。

f(i){                                               i is run-length; not actually passed to f()
    for(                                            Loop over compressed string.
        char*A=" _|/\\()\n",                        Alphabet
        *s="...";                                   Compressed string.
        i=*s>63?:*s++;                             If char is outside symbol range, use as run-length and skip to next. Stop on EOS.
        s++)                                        Advance to next char.
            for(;i--&31;)                           Repeat symbol pair per run-length.
                printf("%c%c",A[*s&7],A[*s/8&7]);   Extract symbols from character and print.
}

在线尝试！

— 腹肌
source
@ceilingcat嗯。没有时髦的输出就无法召回。尽管如此，它还是做了一点调整，也得到了279。
— gastropner
0

Javascript ES6，314个字节

包含不可打印的字节。使用一些黑色JS魔术来运行。如果console.log()需要此答案有效，则字节数为327。

[...`Ãm°Ûm¶Ûm¶Ûm¶Û\`��m¶Ûm¶Ûm¶Ûm�ç�±Çm¶Ûm¶Ûm¶Ûh���¶Ûm°Ûm¶Ûm�<â�8à�À�°�l6Ãm��m��\`�Äl����Ç��§��Ça�ØfqÇ��À�����»
°Ú¬� ó�Øé¦8ã�8ã� ã±Ä�&�â�Ç�4Y�vØnAÛ�X$�HG��\`lv �� ���0��
�Ø�öÛm¶Ûb�Ø�¶���`].map(a=>'0'.repeat(8-(z=a.charCodeAt().toString(2)).length)+z).join``.replace(/.{1,3}/g,a=>`_|/\\()
`[parseInt(a,2)]).slice(0,-2)

这是非常痛苦的事情，我无法摆脱.slice(0,-2):(
明天在我不那么累的时候会在解释中进行编辑。

将每个单个字节替换为相应的十六进制值，以使代码段能够运行

f=_=>
[...`\xc3\x6d\xb0\xdb\x6d\xb6\xdb\x6d\xb6\xdb\x6d\xb6\xdb\x60\x00\x00\x6d\xb6\xdb\x6d\xb6\xdb\x6d\xb6\xdb\x6d\x86\xe7\x1d\xb1\xc7\x6d\xb6\xdb\x6d\xb6\xdb\x6d\xb6\xdb\x68\x00\x00\x0b\xb6\xdb\x6d\xb0\xdb\x6d\xb6\xdb\x6d\x8e\x3c\xe2\x06\x38\xe0\x00\xc0\x01\xb0\x00\x6c\x36\xc3\x6d\x80\x00\x6d\x80\x03\x60\x01\xc4\x6c\x00\x1b\x00\x01\xc7\x9d\x80\xa7\x15\x86\xc7\x61\x99\xd8\x66\x71\xc7\x1d\x8e\xc0\x0b\x96\x1b\x14\x00\xbb\x0a\xb0\xda\xac\x00\xa0\xf3\x8e\xd8\xe9\xa6\x38\xe3\x8e\x38\xe3\x8e\x20\xe3\xb1\xc4\x00\x26\x98\xe2\x00\xc7\x11\x34\x59\x1c\x76\xd8\x6e\x41\xdb\x10\x58\x24\x1c\x48\x47\x12\x16\x60\x6c\x76\x20\x00\x00\xa0\x91\x00\x0b\x30\x05\x00\x0a\x0e\xd8\x83\xf6\xdb\x6d\xb6\xdb\x62\x0e\xd8\x83\xb6\x80\x00\x80`].map(a=>'0'.repeat(8-(z=a.charCodeAt().toString(2)).length)+z).join``.replace(/.{1,3}/g,a=>`_|/\\() 
`[parseInt(a,2)]).slice(0,-2)

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

— 低音提琴（Bassdrop Cumberwubwubwub）
source
2
这是如何运作的？
— 奥利弗·倪
0

JavaScript中，294个 292字节

_='_&3,,& *.,,&_ 7+&+,,-(*.)&&& _,-+7+__1 . .-.3&_& ._&.-*+_-.-.+7|3_)+2_43 b|3 \\+14-*) 2_4/*)3)2_-)2*)_|7+&| 51111 6+-+.51*1_52/+& _ 7|0\\_|6+6/+62\\__44*.)_|6(*2\\*).)07,40&(./,&&&&0_|&6|&- .*_*___1 ++| |3-_4-|- 2/ 5( (6|_7\n';for(Y in $='7652-43+1*.&0,')with(_.split($[Y]))_=join(pop());_

这...是真的只是编码的艺术......与此 ...

如果console.log()需要，则字节数为307305字节。

294-> 292，-2B用于编码\n为7。

— 鸣子
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.