Wyzwanie: Wyprodukuj następujący wynik, używając jak najmniejszej liczby znaków:

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

Zasady i ograniczenia:

• Nie możesz używać FIGLet ani żadnych podobnych narzędzi. (W przeciwnym razie figlet Hello, world!byłoby to trywialne i prawie bezkonkurencyjne rozwiązanie).

• Twój program musi składać się wyłącznie z drukowalnych znaków ASCII - w szczególności punktów kodowych 9 (TAB), 10 (LF) i 32 - 126. (Jeśli twój język / system operacyjny wymaga podziału linii CRLF, możesz użyć tych zamiast zwykłych LF). Tak , niestety dyskwalifikuje to każdy język, który wymaga znaków spoza ASCII (lub danych nietekstowych) jako części składni.

• Dane wyjściowe muszą wyglądać dokładnie tak jak w powyższym przykładzie. Jeśli chcesz, możesz jednak dołączyć dodatkowe białe znaki na wyjściu. Możesz założyć 8-znakowe odstępy między znakami (lub natywne ustawienie domyślne wybranej platformy, jeśli ma spójne ustawienie).

Ps. Aby ustawić tę wartość, wymyśliłem Perl o 199 znakach. Nie opublikuję go jednak na wypadek, gdyby ktoś wymyślił to samodzielnie. (Ponadto jest to trochę tandetne.) Oczywiście nie powinno to zniechęcać do publikowania własnego rozwiązania, nawet jeśli jest ono dłuższe.

Aktualizacja: Teraz, gdy Han pobił go o jeden znak, oto moje tandetne rozwiązanie Perla z 199 znakami:

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'

Jest bardzo podobny do rozwiązania DC (i wszystkich innych rozwiązań opartych na zlib / gzip w różnych językach), tyle że użyłem uuencoding zamiast base64 dla skompresowanego tekstu i kilku innych drobnych sztuczek golfowych.

Aktualizacja 2 : Myślę, że nadszedł czas, aby oficjalnie zaakceptować zwycięzcę. Pierwsze miejsce zajmuje kod PHP konsolenfreddy , ponieważ bez względu na liczbę znaków, jest on jak dotąd najkrótszy. W rzeczywistości połączenie go ze zoptymalizowanym strumieniem DEFLATE z mojego kodu Perla o 199 znakach daje jeszcze krótsze rozwiązanie o 176 znakach:

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

Uważam jednak, że han zasługuje na specjalne wyróżnienie za zbliżenie się bez użycia wcześniej napisanych narzędzi dekompresyjnych. Gratulacje dla was obojga i szczęśliwego nowego roku dla wszystkich!

Stax , 137 bajtów

"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

Uruchom i debuguj

Działa to w ten sposób.

1. Zacznij od dużego literału łańcuchowego.
2. Konwertuj na liczbę całkowitą, dekodując jako liczbę podstawową 90.
3. Konwertuj tę liczbę na wartość binarną.
4. Sekwencje 0s, po których następuje a, 1są tłumaczone na znaki spacji.
5. Wszystkie pozostałe 1s są zastąpione spacjami.
6. Powstały ciąg jest podzielony na 54 znaki.

Perl 5.10 - 195 198 202 203 znaków

Oto wpis, który nie wymaga żadnych bibliotek poza podstawowym dopasowaniem wyrażeń regularnych. Zakodowany ciąg ma 131 znaków, a kod do jego zdekodowania i wydrukowania zajmuje 64 znaki (przy założeniu braku nowego wiersza na końcu źródła). Chodzi o to, aby reprezentować wspólne 3-znakowe łańcuchy małymi literami.

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

Koder jest teraz znacznie dłuższy i niestety nie bardzo czytelny. Podstawową ideą jest użycie programowania dynamicznego, aby znaleźć najkrótsze kodowanie dla każdej linii, biorąc pod uwagę stały zestaw podstawień ciągów. Ciąg podstawień w ostatnim wierszu został zbudowany metodą prób i błędów i możliwe jest, że inny ciąg podstawień może prowadzić do krótszego programu niż powyżej.

Jeden trick jest to, że niektóre podstawienia są krótsze niż 3 znaków: Ze względu na sposób Perla substrprac, xzastępuje się wyrazami " _ ” i y„ _”. To ostatnie jest konieczne, ponieważ \ww wyrażeniach regularnych dopasowuje „ _”, które jest następnie zastępowane przez „ (_)”.

Brainfuck - 862 znaków:

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

Python (2.x), 194 znaki

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

JavaScript, 273 265 264 znaków

" _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]})

:(

Ta odpowiedź jest dłuższa niż tylko wydrukowanie łańcucha; jednakże, dla zabawy, oto:

Python, 485 znaków ☺

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

Ponieważ mam jedną z najkrótszych reprezentacji skompresowanego tekstu ASCII, muszę mieć najdłuższy pasek przewijania w moim kodzie! To zwycięstwo! :)

PHP, 194 189 znaków

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

Zasadniczo jest taki sam jak odpowiedź na Python i Perl, nieco krótszy

W innych językach: C (wersja oryginalna), 209 znaków ; Perl , 200 znaków .

J, 167160 znaków (47 + 113)

Kolejny komunikat o braku wbudowanej kompresji. Wykorzystuje dość proste kodowanie o zmiennej długości, kodując każdy znak jako serię 1 bitów i oddzielając znaki przez 0 bitów. Skompresowany ciąg ma zaledwie 113 znaków.

('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 znaków

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

Całkiem proste ... niezbyt zadowolone z tej próby.

Bash, 199 196 193 znaków

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

Wystarczająco blisko...

EDYCJA: do 193!

bash, 196 192

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

Perl, 230 znaków

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

Jest to w zasadzie to samo, co moja odpowiedź w języku Python. Chciałbym zobaczyć wersję 199 znaków. Brzmi jak magia.

Perl, 294 290 bajtów.

Sam skompresowany ciąg to 151 130 bajtów.

To nie jest krótkie, ale pisanie było naprawdę fajne.

@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 bajtów

Sam skompresowany ciąg ma 111 bajtów.

@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

Próbując zrozumieć, co key= (0,(1,((((7,5),(6,(8,(11,(9,10))))),(4,3)),2))) robi python , ostatecznie stworzyłem bardzo podobną wersję perla.

PHP 590

oczywiście, nie próbuję wygrać, po prostu zainteresowałem się wypróbowaniem innego schematu kompresji, chociaż nie jest nawet w stanie pokonać prostszego rozwiązania PHP z 302 zwykłym tekstem polegającego na kopiowaniu i wklejaniu

działa jako mapa bitowa na 10 kanałach

„golfa”

<? $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";}

czytelny

<?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 bajtów

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

Nie mogłem znaleźć żadnych klasycznych metod kodowania, więc prawdopodobnie nie konkuruję.

Golf-Basic 84, 325

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

Zakładając, że kalkulator może drukować znaki odwrotne, ukośniki odwrotne, pojedyncze potoki i podkreślenia.

HTML + JS (223 znaki Unicode)

Dla żartu:

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

Uwaga: musisz zapisać go w pliku HTML „UTF-8 with BOM”.

PowerShell , 220 bajtów = skrypt: 9 + archiwum: 211

tar xOf t

Wypróbuj online!

Skrypt Powershell do utworzenia archiwum t(patrz TIO):

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