Thách thức: Tạo đầu ra sau bằng cách sử dụng càng ít ký tự càng tốt:

 _   _      _ _                             _     _ _
| | | | ___| | | ___    __      _____  _ __| | __| | |
| |_| |/ _ \ | |/ _ \   \ \ /\ / / _ \| '__| |/ _` | |
|  _  |  __/ | | (_) |   \ V  V / (_) | |  | | (_| |_|
|_| |_|\___|_|_|\___( )   \_/\_/ \___/|_|  |_|\__,_(_)
                    |/

Các quy tắc và hạn chế:

• Bạn không được sử dụng FIGLet hoặc bất kỳ công cụ tương tự nào. (Nếu không, figlet Hello, world!sẽ là một giải pháp tầm thường và khá nhiều vô địch.)

• Chương trình của bạn phải bao gồm toàn bộ các ký tự ASCII có thể in được - cụ thể là các điểm mã 9 (TAB), 10 (LF) và 32 - 126. (Nếu ngôn ngữ / HĐH của bạn yêu cầu ngắt dòng CRLF, bạn có thể sử dụng các ký tự thay vì các dòng chữ đơn giản.) Có , điều này đáng tiếc không đủ tiêu chuẩn cho bất kỳ ngôn ngữ nào yêu cầu các ký tự không phải ASCII (hoặc dữ liệu phi văn bản) như là một phần của cú pháp của nó.

• Đầu ra phải trông giống hệt như ví dụ trên. Tuy nhiên, bạn có thể bao gồm thêm khoảng trắng xung quanh đầu ra nếu bạn muốn. Bạn có thể giả định khoảng cách tab 8 ký tự (hoặc cài đặt mặc định gốc của nền tảng bạn đã chọn, nếu nó có một khoảng nhất quán).

Thi thiên Để đặt mệnh giá, tôi đã đưa ra giải pháp Perl 199 char. Tuy nhiên, tôi sẽ không đăng nó trong trường hợp ai đó nghĩ ra nó một cách độc lập. (Ngoài ra, đó là loại vui nhộn.) Tất nhiên, điều này không khuyến khích bạn đăng giải pháp của riêng bạn, ngay cả khi nó dài hơn.

Cập nhật: Bây giờ han đã đánh bại nó bằng một char, đây là giải pháp Perl 199-char tuyệt vời của tôi:

use Compress'Zlib;say uncompress unpack u,'M>-I]BT$*`S$,`^]YQ=R:0,&_Z<DP?8@?WVQJ]E2J"%E$$@)R(/(/MCJ*\U!OM`Z#=5`4Y>6M=L\L%DMP&DB0V.4GQL&OOGB$4:%`4TT4!R8O-Z(^BTZWNV?>F86K:9+""-35*-LNC:T^D:_$#%^`";"DD0'

Nó rất giống với giải pháp của DC (và tất cả các giải pháp dựa trên zlib / gzip khác trong các ngôn ngữ khác nhau), ngoại trừ việc tôi đã sử dụng uuencoding thay vì base64 cho văn bản nén và một vài thủ thuật đánh gôn nhỏ khác.

Cập nhật 2 : Tôi nghĩ đã đến lúc chính thức chấp nhận một người chiến thắng. Vị trí đầu tiên thuộc về mã PHP của konsolenfreddy , vì, tuy nhiên, bạn đếm các ký tự, đây là mã ngắn nhất được gửi cho đến nay. Trong thực tế, kết hợp nó với luồng DEFLATE được tối ưu hóa từ mã Perl 199 char của tôi mang lại giải pháp 176 char thậm chí còn ngắn hơn:

<?=gzinflate(base64_decode("fYtBCgMxDAPvecXcmkDBv+nJMH2IH99savZUqghZRBICciDyD7Y6ivNQbwOg3VQFOXlrXbPLBZLcBpIkNjlJ8bBr754hFGhQFNNFAcmLzeiPotOt7tn3plq2mSwgjU1SjbLo2tPpGvxAxfgA"));

Tuy nhiên, tôi nghĩ rằng han xứng đáng được đề cập danh dự đặc biệt vì đã đến rất gần mà không sử dụng bất kỳ công cụ giải nén được viết sẵn nào. Chúc mừng cả hai bạn, và chúc mừng năm mới mọi người!

Stax , 137 byte

"9&BO]h>&)>3ieuCoKVKVnuOoT'E-^Z(1.3u[);h1[RTOGqTZkoQx?KMy&9ctG&*y~HxR9%GYn.rYMdMcOOq^wXc@%zy*P[*Q"90|E|B"0+1"{%",``_|\/()V'"@]}R.1 |t54/m

Chạy và gỡ lỗi nó

Nó hoạt động như thế này.

1. Bắt đầu với một chuỗi lớn theo nghĩa đen.
2. Chuyển đổi sang số nguyên bằng cách giải mã dưới dạng số cơ sở 90.
3. Chuyển đổi số đó thành nhị phân.
4. Các lần chạy 0theo sau 1được dịch thành các ký tự không phải dấu cách.
5. Tất cả các 1s còn lại được thay thế bằng khoảng trắng.
6. Chuỗi kết quả được chia thành các dòng 54 ký tự.

Perl 5.10 - 195 198 202 203 ký tự

Đây là một mục không yêu cầu bất kỳ thư viện nào ngoài kết hợp regrec cơ bản. Chuỗi được mã hóa là 131 ký tự và mã để giải mã và in nó cần tới 64 ký tự (giả sử không có dòng mới nào ở cuối nguồn). Ý tưởng là biểu diễn các chuỗi 3 ký tự phổ biến bằng các chữ cái viết thường.

s!!xfefxxf\t\t\tf efyx
no| cnocfxefxceyxm|xmn
nm|wtnwtgt/uvy \\| 'ym|w`o|
pepyy/o| _ogrr/ _opn (ml
l lbyly|by( )fiihyjm lb,y_
\t\tf |/!;s!\w!substr'(_)\___   \_/|_| |  V \ / _',-95+ord$&,3!eg;say

Bộ mã hóa dài hơn rất nhiều và không may là không thể đọc được ngay bây giờ. Ý tưởng cơ bản là sử dụng lập trình động để tìm mã hóa ngắn nhất cho mỗi dòng, được cung cấp một bộ thay thế chuỗi cố định. Chuỗi thay thế trên dòng cuối cùng được xây dựng bằng thử nghiệm và lỗi, và có thể một chuỗi thay thế khác có thể dẫn đến một chương trình ngắn hơn ở trên.

Một mẹo ở đây là một số thay thế dài hơn 3 ký tự: do cách thức substrhoạt động của perl , xđược thay thế bằng ' _' và ybởi ' _'. Cái sau là cần thiết bởi vì \wtrong regex khớp với ' _', sau đó được thay thế bằng ' (_)'.

Brainfuck - 862 ký tự:

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

Python (2.x), 194 ký tự

print'eNo9T8ENxCAMe5cp/DsqVco2fSH5BsnwZ4ccEIhxbAIgAK9KvDRwGBEjsSfJA6r2N7EISbmrpbLNKFRYOABaC6FAEYkPW/Ztm1t7Z1S3ydtHuV4ooolEV6vPyJ2XH8kGE7d9DAVMhFUte6h7xv5rxg8sf0Qc'.decode('base64').decode('zip')

Javascript, 273 265 264 ký tự

" _2_22_ _2222222226_26_ _10 0 3_0 | 3_2 32233_6_ 30 30 |10_0/ _ 4 0/ _ 424 4 /4 / / _ 4| '30/ _` 01|6_6|63/ 0 (_) |24 V6V / (_) 060 (_0_|1|_0_|43_|_543_( )24_/4_/ 43_/56543,_(_)12222226|/".replace(/\d/g,function(a){return'| |,\n,   ,__,\\,|_|,  '.split(',')[a]})

:

Câu trả lời này dài hơn việc chỉ in chuỗi; tuy nhiên, chỉ để cho niềm vui của nó, đây là:

Python, 485 ký tự

import sys

data= ',C6UBKq.)U^\\ 8[hHl7gfLFyX6,;p\'SlYpN@K-`Kbs#fSU+4o~^_h\\dJDy{o9p?<GnLTgG{?ZM>bJE+"[kHm7EavoGcS#AQ^\\>e_'
table= " _|\\/(\n)V'`,"
key= (0,(1,((((7,5),(6,(8,(11,(9,10))))),(4,3)),2)))

number= 0
for char in data:
    number= number*95 + ord(char) - 32

mask= 1<<655
decoder= key
while mask:
    index= mask & number and 1
    try:
        decoder= decoder[index]
    except TypeError:
        sys.stdout.write(table[decoder])
        decoder= key[index]
    mask>>= 1

Vì tôi có một trong những biểu diễn ASCII ngắn nhất của văn bản gốc được nén, tôi phải có thanh cuộn dài nhất trong mã của mình! Đó là một chiến thắng! :)

PHP, 194 189 ký tự

php -r'=gzinflate(base64_decode("dU/BDcQgDPszhX+lUqVs0xeSb5AMf3ZI+7qDACa2EwABeNXR4M/goxqJPUm+oLinEishKTdbKtuMQsTCC6C1EApUInHIvOlP+9zbO6PaTZ6+ynZDEZ1INFuNRu5z+ZVsMHHax1DAibCqZRdVZ/z6esYX"));'

Về cơ bản nó giống như câu trả lời của Python và Perl, ngắn hơn một chút

Trong các ngôn ngữ khác: C (phiên bản gốc), 209 ký tự ; Perl , 200 ký tự .

J, 167 160 ký tự (47 + 113)

Một đệ trình không nén dựng sẵn. Sử dụng một mã hóa có độ dài thay đổi khá đơn giản, mã hóa mỗi ký tự thành một chuỗi gồm 1 bit và phân tách các ký tự bằng 0 bit. Chuỗi nén chỉ có 113 ký tự.

('a _|\/',CR,'()V`,'''){~#;.2,(6$2)#:40-~3&u:'8H1(((((H:f[4ZS4ZP2(RPMAMANf[>CZD[F;I[OVFF;TgfS5aGd[7T9JW4[eG[+Of7ddg?d[.AfT]WUASE=S>bSdgI]cS[RWBYSE?gSeG_X(()WG('

Python (2.7.x), 218 ký tự

import base64,zlib;
print zlib.decompress(base64.b64decode("eNo9T8ENxCAMe5cp/DsqVco2fSH5BsnwZ4ccEIhxbAIgAK9KvDRwGBEjsSfJA6r2N7EISbmrpbLNKFRYOABaC6FAEYkPW/Ztm1t7Z1S3ydtHuV4ooolEV6vPyJ2XH8kGE7d9DAVMhFUte6h7xv5rxg8sf0Qc"))

Khá đơn giản ... không hài lòng lắm với nỗ lực này.

Bash, 199 196 193 ký tự

base64 -d<<<H4sIAAAAAAAAAz1PQQ6AIAw7S+IfelMTk/3GE0l9CI+3HRPYoHQtAxCAMzduGliMiL0NzElygSz+LiYhLWc1VekzDFU6FoCyIxRIYuBgyd7f5+5eGdnv5OWjbA8UUcRAVbORfBN0v5MFTlw2MhQwEVaV7KYu2tv88IgPjUlb7QoBAAA=|zcat

Đủ gần...

EDIT: Xuống tới 193!

bash, 196 192

base64 -d<<<H4sIAO4SqFMCA3VPQQ7AIAi7+4re5pIl/GYnk+4hPH4U0dOmILUUUBCAPEOBn8Wlao65SW6QudWJSYSUM5sqlQlZJAY2QPiAhSEJx8GSPVWm0TppOa3z1DWqboRZEY7K5pzmMw49kgU6TtXRwiDCpCrZxejTvn7u1l5z59MGKQEAAA|zcat

Perl, 230 ký tự

use Compress::Zlib;
use MIME::Base64;
print uncompress(decode_base64('eNo9T8ENxCAMe5cp/DsqVco2fSH5BsnwZ4ccEIhxbAIgAK9KvDRwGBEjsSfJA6r2N7EISbmrpbLNKFRYOABaC6FAEYkPW/Ztm1t7Z1S3ydtHuV4ooolEV6vPyJ2XH8kGE7d9DAVMhFUte6h7xv5rxg8sf0Qc'));

Điều này về cơ bản giống như câu trả lời Python của tôi. Tôi muốn xem phiên bản 199 ký tự .. nghe có vẻ ma thuật.

Perl, 294 290 byte.

Chuỗi nén một mình, là 151 130 byte.

Điều này không phải là ngắn, nhưng nó thực sự thú vị để viết.

@t=split//,"_|\\/\n()V',`";$b.=substr unpack("B8",chr(-48+ord)),2,6 for split//,'Ph?`@Ooooo1l410````0066600?03l0001PP06600HHB1Q064L4D<8h8^::<DLL4@J0032>1D<90h<>00hHI@6QhYllLX3@`hHI@1Q04P@1Q04@002080R001I^80a074001Q07208P0B0X34ooo`ST';$b=~s/(1)|(0.{4})/$1?" ":$t[ord pack"B8","000$2"]/eg;print$b

@t=split//," _|x"x4 ."\\/\n()V',`";$b.=substr unpack("B8",chr(-48+ord)),2,6 for split//,'4100A0000000001017:8R5HR5@1@05E15R5R;:9Ra4`8\\A<0<30a`<C4C2=URa7PRbP@PG4R<g@P<3D=C4cM288S=RK:HV`EVK1G<d0`LL74`EaV2K1Mg=db0000002ab';$b=~s/1(1.{4})|(..)/$t[ord pack"B8","000".($2?"000$2":$1)]/eg;print$b

Perl, 346 byte

Chỉ riêng chuỗi nén là 111 byte.

@t = split//, " _|\\/\n()V',`";
$k=[0,[1,[2,[[3,4],[[5,6],[7,[[8,9],[10,11]]]]]]]];

$b .= substr unpack("B8", chr(-48+ord)), 2, 6 for split//,'@P900000PBlc<b[<bX:0ZXUIUIVlcFKZLI^Y`LLMhjjW<oJcMGncNHS5MIW]l`ho3lMNgc<IW]V]i[=KUF]KUG[hL^l^^EMeSFiGmNggP001^Pl';

$d = $k;
$o.=$d=~/^\d/?$t[$s=$d,$d=$$k[$_],$s]:($d=$$d[$_],"")for split//,$b;
print $o

Cố gắng hiểu con trăn key= (0,(1,((((7,5),(6,(8,(11,(9,10))))),(4,3)),2))) đang làm gì, cuối cùng tôi đã tạo ra một phiên bản perl trông rất giống nhau.

PHP 590

rõ ràng, tôi không cố gắng để giành chiến thắng, chỉ quan tâm đến việc thử một sơ đồ nén khác, thậm chí nó không thể đánh bại giải pháp PHP văn bản đơn giản 302 đơn giản hơn chỉ là dán sao chép

nó hoạt động như một bitmap trên 10 kênh

"đánh gôn"

<? $l=['_'=>['l8kqo,ei','9uo6,2fko0','52m0w,5r1c','540lc,5maq','lifeo,19i7ai'],'|'=>[0,'1h39j4,105','1h2k8w,q9x','14l2jk,wlx','1h39j4,wlc','1s,0'],'/'=>[2=>'b9c0,n3kao','pa8,18y68','0,mihog','w,0'],'\\'=>[2=>'pc5,a0zy8','2,0','b9c1,am2kg'],'('=>[3=>'e8,b8lc','1s,4'],')'=>[3=>'3k,2t4w','g,1'],'V'=>[3=>'0,18y680'],'`'=>[2=>'0,g'],"'"=>[2=>'0,6bk'],','=>[4=>'0,g'],];$p=@str_pad;$b=@base_convert;$i=-1;while($i++<5){$h=' ';foreach($l as$c=>$r)if(@$r[$i]){$a=explode(',',$r[$i]);$d=str_split($p($b($a[0],36,2),27,0,0).$p($b($a[1],36,2),27,0,0));foreach($d as$j=>$v)$v&&$h[$j]=$c;}echo"$h\n";}

có thể đọc được

<?php
$l = ['_'=>['l8kqo,ei','9uo6,2fko0','52m0w,5r1c','540lc,5maq','lifeo,19i7ai'],
      '|'=>[0,'1h39j4,105','1h2k8w,q9x','14l2jk,wlx','1h39j4,wlc','1s,0'],
      '/'=>[2=>'b9c0,n3kao','pa8,18y68','0,mihog','w,0'],
     '\\'=>[2=>'pc5,a0zy8','2,0','b9c1,am2kg'],
      '('=>[3=>'e8,b8lc','1s,4'],
      ')'=>[3=>'3k,2t4w','g,1'],
      'V'=>[3=>'0,18y680'],
      '`'=>[2=>'0,g'],
      "'"=>[2=>'0,6bk'],
      ','=>[4=>'0,g'],
      ];
$p=@str_pad;
$b=@base_convert;
$i=-1;
while($i++<5){
    $h = str_repeat(' ',54);
    foreach($l as $c=>$r)
        if(@$r[$i]){
        $a = explode(',',$r[$i]);
        $d = str_split($p($b($a[0],36,2),27,0,0).$p($b($a[1],36,2),27,0,0));
        foreach($d as$j=>$v)
            if ($v)
                $h[$j]=$c;
        }
    echo "$h\n";
}

Pylongolf2, 300 byte

" _   _      _ _                             _     _ _
| | | | ___| | | ___    __      _____  _ __| | __| | |
| |_| |/ _ \ | |/ _ \   \ \ /\ / / _ \| '__| |/ _` | |
|  _  |  __/ | | (_) |   \ V  V / (_) | |  | | (_| |_|
|_| |_|\___|_|_|\___( )   \_/\_/ \___/|_|  |_|\__,_(_)
                    |/"~

Tôi không thể tìm thấy bất kỳ phương pháp mã hóa đẳng cấp nào, vì vậy tôi có thể không cạnh tranh.

Golf-Basic 84, 325

:"                     "_Str1t` _   _      _ _ "d`Str1d`Str1t`_     _ _"t`| | | | ___| | | ___    __      _____  _ __| | __| | |"t`| |_| |/ _ \ | |/ _ \   \ \ /\ / / _ \| '__| |/ _` | |"t`|  _  |  __/ | | (_) |   \ V  V / (_) | |  | | (_| |_|"t`|_| |_|\___|_|_|\___( )   \_/\_/ \___/|_|  |_|\__,_(_)"t`                    |/"

Giả sử một máy tính có thể in backticks, dấu gạch chéo ngược, đường ống đơn và dấu gạch dưới.

HTML + JS (223 ký tự unicode)

Chỉ để cho vui:

<body onload=p.innerHTML=unescape(escape("𘁟𘀠𘁟𘀠𘀠𘀠𧰠𧰠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𧰠𘀠𘀠𧰠𧰊𯀠𯀠𯀠𯀠𧱟𧱼𘁼𘁼𘁟𧱟𘀠𘀠𧱟𘀠𘀠𘀠𧱟𧱟𧰠𘁟𘁟𧱼𘁼𘁟𧱼𘁼𘁼𒡼𘁼𧱼𘁼𛰠𧰠𧀠𯀠𯀯𘁟𘁜𘀠𘁜𘁜𘀯𧀠𛰠𛰠𧰠𧁼𘀧𧱟𯀠𯀯𘁟𨀠𯀠𯀊𯀠𘁟𘀠𯀠𘁟𧰯𘁼𘁼𘀨𧰩𘁼𘀠𘁜𘁖𘀠𥠠𛰠𚁟𚐠𯀠𯀠𘁼𘁼𘀨𧱼𘁼𧱼𒡼𧱼𘁼𧱼𧁟𧱟𯁟𯁟𯁜𧱟𧰨𘀩𘀠𘁜𧰯𧁟𛰠𧁟𧱟𛱼𧱼𘀠𯁟𯁜𧱟𛁟𚁟𚐊𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𯀯").replace(/uD./g,''))><pre id=p>

Lưu ý: bạn phải lưu nó trong tệp HTML "UTF-8 with BOM".

PowerShell , 220 byes = script: 9 + lưu trữ: 211

tar xOf t

Hãy thử trực tuyến!

Tập lệnh Powershell để tạo kho lưu trữ t(xem TIO):

(
" _   _      _ _                             _     _ _",
"| | | | ___| | | ___    __      _____  _ __| | __| | |",
"| |_| |/ _ \ | |/ _ \   \ \ /\ / / _ \| '__| |/ _` | |",
"|  _  |  __/ | | (_) |   \ V  V / (_) | |  | | (_| |_|",
"|_| |_|\___|_|_|\___( )   \_/\_/ \___/|_|  |_|\__,_(_)",
"                    |/"
) | Set-Content f -Force
tar zcfo t f
Get-ChildItem t # output info about archive size