14
\$\begingroup\$

Challenge: Produce the following output using as few chars as possible:

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

Rules and restrictions:

  • You may not use FIGLet or any similar tools. (Otherwise, figlet Hello, world! would be a trivial and pretty much unbeatable solution.)

  • Your program must consist entirely of printable ASCII characters — specifically, code points 9 (TAB), 10 (LF) and 32 – 126. (If your language / OS requires CRLF line breaks, you may use those instead of plain LFs.) Yes, this regrettably disqualifies any language that requires non-ASCII characters (or non-textual data) as part of its syntax.

  • The output must look exactly like the example above. You may, however, include extra whitespace around the output if you want. You may assume 8-character tab spacing (or your chosen platform's native default setting, if it has a consistent one).

Ps. To set the par, I came up with a 199-char Perl solution. I won't post it yet, though, in case someone comes up with it independently. (Also, it's kind of cheesy.) Of course, this shouldn't discourage you from posting your own solution, even if it's longer.

Update: Now that han has beaten it by one char, here's my cheesy 199-char Perl solution:

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&OOGB4ドル:%`4TT4!R8O-Z(^BTZWNV?>F86K:9+""-35*-LNC:T^D:_$#%^`";"DD0'

It's very similar to D C's solution (and all the other zlib/gzip-based solutions in various languages), except that I used uuencoding instead of base64 for the compressed text and a few other minor golfing tricks.

Update 2: I think it's time to officially accept a winner. The first place goes to konsolenfreddy's PHP code, since, however you count the chars, it is the shortest submitted so far. In fact, combining it with the optimized DEFLATE stream from my 199-char Perl code yields an even shorter 176-char solution:

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

However, I do think that han deserves a special honorary mention for getting so close without using any pre-written decompression tools. Congratulations to both of you, and a happy new year to everyone!

asked Dec 15, 2011 at 21:44
\$\endgroup\$
1
  • \$\begingroup\$ Ok, I have to do this one in C... \$\endgroup\$ Commented Dec 29, 2011 at 20:41

21 Answers 21

17
\$\begingroup\$

Perl 5.10 - 195 (削除) 198 (削除ここまで) (削除) 202 (削除ここまで) (削除) 203 (削除ここまで) characters

Here's an entry that does not require any libraries beyond basic regexp matching. The encoded string is 131 characters, and the code to decode and print it takes up 64 characters (assuming no newline at the end of the source). The idea is to represent common 3-character strings by lower case letters.

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

The encoder is a lot longer and unfortunately not very readable right now. The basic idea is to use dynamic programming to find the shortest encoding for each line, given a fixed set of string substitutions. The string of substitutions on the last line was built by trial and error, and it is possible that another string of substitutions might lead to a shorter program than above.

One trick here is that some substitutions are shorter than 3 characters long: due to the way perl substr works, x is replaced by ' _' and y by '_'. The latter is necessary because \w in the regex matches '_', which is then replaced by '(_)'.

answered Dec 18, 2011 at 22:05
\$\endgroup\$
8
  • \$\begingroup\$ +1, very nice. You can save 2 chars by replacing print by say \$\endgroup\$ Commented Dec 19, 2011 at 13:04
  • \$\begingroup\$ @M42: As far as I could figure out, on perl 5.10 to use say you need to either do use 5.010; or run the script as a one-liner with perl -E 'script here'. The former makes the code longer and the latter is not appropriate for a multi-line script. Did I miss something? \$\endgroup\$ Commented Dec 19, 2011 at 13:47
  • \$\begingroup\$ The -E doesn't count in number of char. \$\endgroup\$ Commented Dec 19, 2011 at 14:04
  • 1
    \$\begingroup\$ Ps. You can save a few more chars by using s''...' instead of $_=q!...!; just remember to escape the single quote. With that and say instead of print (and leaving out the last newline), I get this down to 198 chars. \$\endgroup\$ Commented Dec 21, 2011 at 7:21
  • 3
    \$\begingroup\$ BTW, I tried using tabs instead of # for the long runs of whitespace and got your solution down to 190 chars. I wonder if going below 184 chars is possible -- that would beat all the zlib-compressed solutions so far. \$\endgroup\$ Commented Dec 22, 2011 at 2:29
15
\$\begingroup\$

Brainfuck - 862 characters:

>++++[<++++++++>-]>-----[<---->---]<+++>>--[<+>--]<---<<.>.<...>.<....
..>.<.>.<.............................>.<.....>.<.>.>>++++++++++.<.<<.
>>.<<.>>.<<.>>.<<.>...>.<<.>>.<<.>>.<<.>...<....>..<......>.....<..>.<
.>..>.<<.>>.<<.>..>.<<.>>.<<.>>.>.<.<<.>>.<.>.<<.>>.>>>-[<->+++++]<---
-.<<<<.>.<.>---.+++<.>>.<<.>>.>>.<<<<.>.<.>---.<...>.<.>.<.>>>>.<<<.<.
>>>>.<<<<.>>>>.<<<<.>+++.<.>---.>.<<.>>>>>>---[<+>+++++++]<++.<<<<+++.
.>.<<.>>.>>.<<<<.>.+.-<.>>.<<.>>.>.<.<<..>.<..>>.<<..>..>>>.<<<<.>>.<<
.>>.<<.>>>>>+.<<<<.>>>>+.<<<<<.>>.<<...>---.<.>------.<..>.<.>>>>.<<<<
.>>>>>-.<<<<+++++++++.>>>>+.<<<<<.>>.<<.>>.<<..>>.<<.>>.<<.>>>>>-.<<<<
.>.<<.>>.<.>.>.<.<.>.<<.>>.<.>.<---.+++...>.<.>.<.>.<---.+++...>>>>.<<
<<<.>>>>>+.<<<<<...>---.+++.>>>.<<<---.+++.>>>.<<<<.>---.+++...>>>.<<.
<.>.<<..>>.<.>.<---.+++..>>>>+++.<<<<.>>>>----.<<<<.>>>>+.<<.<<<......
..............>>.>>.<.
answered Dec 15, 2011 at 23:07
\$\endgroup\$
5
  • 1
    \$\begingroup\$ Note that this code apparently assumes 8-bit cells; I first tried it on an interpreter with 32-bit cells, and it got stuck at [<---->---] on the first line. (Presumably it would eventually have finished, but I didn't wait long enough for that.) \$\endgroup\$ Commented Dec 16, 2011 at 1:03
  • 24
    \$\begingroup\$ How the heck did you write this in two hours? \$\endgroup\$ Commented Dec 16, 2011 at 2:52
  • \$\begingroup\$ looks like you save ` ')(,/|V_\n on the first cells and them you just go back and forth printing the needed char (BF Dev text generator?). Nice work BTW \$\endgroup\$ Commented Dec 16, 2011 at 3:13
  • \$\begingroup\$ It does depend on 8 bit wrapping cells. Stores a few common characters like you said, but not all. Also does things like switches between '\' and '_' in one cell where they are close enough to do so. \$\endgroup\$ Commented Dec 16, 2011 at 5:26
  • 1
    \$\begingroup\$ @JBernardo, BF dev text generator gave code much bigger than this. It would take a much more complicated generator to beat this I think. \$\endgroup\$ Commented Dec 16, 2011 at 5:28
9
\$\begingroup\$

Python (2.x), 194 characters

print'eNo9T8ENxCAMe5cp/DsqVco2fSH5BsnwZ4ccEIhxbAIgAK9KvDRwGBEjsSfJA6r2N7EISbmrpbLNKFRYOABaC6FAEYkPW/Ztm1t7Z1S3ydtHuV4ooolEV6vPyJ2XH8kGE7d9DAVMhFUte6h7xv5rxg8sf0Qc'.decode('base64').decode('zip')
answered Dec 16, 2011 at 20:23
\$\endgroup\$
1
  • 3
    \$\begingroup\$ This answer just made my day xD. I would have never thought I would see a codegolf that actually uses zip&base64 to decrease string size \$\endgroup\$ Commented Mar 8, 2014 at 5:36
4
\$\begingroup\$

Javascript, (削除) 273 (削除ここまで) (削除) 265 (削除ここまで) 264 characters

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

:(

answered Dec 17, 2011 at 15:18
\$\endgroup\$
1
  • \$\begingroup\$ Save the space after the return, -1 char :) \$\endgroup\$ Commented Dec 31, 2011 at 11:32
4
\$\begingroup\$

This answer is longer than just printing the string; however, just for the fun of it, here it is:

Python, 485 characters ☺

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

Since I have one of the shortest ASCII representations of the compressed original text, I must have the longest scrollbar in my code! It's a win! :)

answered Dec 16, 2011 at 22:10
\$\endgroup\$
4
  • 4
    \$\begingroup\$ AKA "my scrollbar is longer than yours" \$\endgroup\$ Commented Dec 16, 2011 at 22:14
  • \$\begingroup\$ This solution can be golfed down to 254 characters. Do you mind if I edit in the shorter version? \$\endgroup\$ Commented Dec 20, 2011 at 19:40
  • \$\begingroup\$ @han: Of course the character count can be reduced; however, I didn't write this one as a serious candidate. So let this one be voted for its own merit, and write another answer using as much or as little of this answer as you like :) \$\endgroup\$ Commented Dec 20, 2011 at 20:36
  • \$\begingroup\$ Thanks, I'll pass unless someone else is really interested. I just wanted to point out that this solution can be made significantly shorter than the original text. \$\endgroup\$ Commented Dec 21, 2011 at 17:52
4
\$\begingroup\$

In other languages: C (original version), 209 chars; Perl, 200 chars.

J, (削除) 167 (削除ここまで) 160 chars (47 + 113)

Another no-builtin-compression submission. Uses a pretty straightforward variable-length encoding, encoding each character as a series of 1 bits and separating characters by 0 bits. The compressed string is a mere 113 characters.

('a _|\/',CR,'()V`,'''){~#;.2,(62ドル)#: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('
answered Feb 8, 2014 at 13:33
\$\endgroup\$
3
\$\begingroup\$

PHP, (削除) 194 (削除ここまで) 189 characters

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

It's basically the same as the Python and Perl answer, slightly shorter

answered Dec 16, 2011 at 8:00
\$\endgroup\$
3
  • \$\begingroup\$ The php -r'=...' trick doesn't seem to work for me, but you could just use <?=... for 184 chars. Also, your output seems to have an extra space where the r and l meet. \$\endgroup\$ Commented Dec 16, 2011 at 14:16
  • \$\begingroup\$ OSX 5.3.6 works fine with the -r'=..'. does the php -r not count? It's included in my 189chars... \$\endgroup\$ Commented Dec 16, 2011 at 15:32
  • \$\begingroup\$ Generally, the name of the interpreter doesn't count. For command line options, I've been going by this meta thread; PHP's -r switch is something of a borderline case, though, since, besides just taking code as a parameter and running it, it also modifies the parsing environment slightly compared to running the code from a file. I'd be inclined to count it as 2 extra chars -- which incidentally puts it even with <?. \$\endgroup\$ Commented Dec 16, 2011 at 15:53
2
\$\begingroup\$

Stax, 137 bytes

"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

Run and debug it

It works like this.

  1. Start with a big string literal.
  2. Convert to integer by decoding as a base-90 number.
  3. Convert that number to binary.
  4. Runs of 0s followed by a 1 are translated into non-space characters.
  5. All remaining 1s are replaced with spaces.
  6. The resulting string is split into 54-character lines.
answered Jul 24, 2019 at 5:03
\$\endgroup\$
1
  • \$\begingroup\$ Congrats, looks like this is the shortest solution now! :) \$\endgroup\$ Commented Jul 24, 2019 at 8:06
2
\$\begingroup\$

Python (2.7.x), 218 characters

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

Pretty straightforward... not terribly pleased with this attempt.

answered Dec 16, 2011 at 4:59
\$\endgroup\$
2
\$\begingroup\$

Bash, (削除) 199 (削除ここまで) (削除) 196 (削除ここまで) 193 characters

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

Close enough...

EDIT: Down to 193!

answered Dec 16, 2011 at 5:27
\$\endgroup\$
2
  • 1
    \$\begingroup\$ Nice. You could save three more chars by replacing gzip -d with zcat. \$\endgroup\$ Commented Dec 16, 2011 at 5:31
  • 3
    \$\begingroup\$ Using a where-string would save over echo. \$\endgroup\$ Commented Dec 16, 2011 at 13:39
2
\$\begingroup\$

bash, (削除) 196 (削除ここまで) 192

base64 -d<<<H4sIAO4SqFMCA3VPQQ7AIAi7+4re5pIl/GYnk+4hPH4U0dOmILUUUBCAPEOBn8Wlao65SW6QudWJSYSUM5sqlQlZJAY2QPiAhSEJx8GSPVWm0TppOa3z1DWqboRZEY7K5pzmMw49kgU6TtXRwiDCpCrZxejTvn7u1l5z59MGKQEAAA|zcat
answered Jun 23, 2014 at 11:47
\$\endgroup\$
1
\$\begingroup\$

Perl, 230 characters

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

This is basically the same as my Python answer. I'd like to see the 199-character version.. sounds like magic.

answered Dec 16, 2011 at 5:13
\$\endgroup\$
1
  • \$\begingroup\$ I won't post it quite yet, but you're on the right track. Of course, I am/was sort of hoping that someone would beat it with a completely different approach. \$\endgroup\$ Commented Dec 16, 2011 at 5:34
1
\$\begingroup\$

Perl, (削除) 294 (削除ここまで) 290 bytes.

The compressed string alone, is (削除) 151 (削除ここまで) 130 bytes.

This isn't short, but it was really fun to write.

@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","0002ドル"]/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ドル?"0002ドル":1ドル)]/eg;print$b
\$\endgroup\$
1
\$\begingroup\$

Perl, 346 bytes

The compressed string alone, is 111 bytes.

@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

Trying to understand what the python with key= (0,(1,((((7,5),(6,(8,(11,(9,10))))),(4,3)),2))) was doing, I ended up making a very similar looking perl version.

answered Jan 6, 2014 at 6:54
\$\endgroup\$
1
\$\begingroup\$

PHP 590

obviously, i'm not trying to win, just got interested on trying another compression scheme, altough it can't even beat the simpler 302 plain text PHP solution of just copy-pasting

it works as a bitmap on 10 channels

"golfed"

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

readable

<?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";
}
answered Feb 6, 2014 at 19:26
\$\endgroup\$
1
\$\begingroup\$

Pylongolf2, 300 bytes

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

I couldn't find any classy encoding methods, so I'm probably not competing.

answered Apr 2, 2016 at 19:45
\$\endgroup\$
0
\$\begingroup\$

Golf-Basic 84, 325

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

Assuming a calculator could print backticks, backslashes, single pipes, and underscores.

answered Dec 9, 2013 at 23:36
\$\endgroup\$
0
\$\begingroup\$

HTML + JS (223 unicode characters)

Just for fun:

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

NB: you have to save it in a "UTF-8 with BOM" HTML file.

answered Jan 5, 2014 at 16:32
\$\endgroup\$
2
  • 1
    \$\begingroup\$ Nice. Works for me even without a BOM (Firefox 26 / Chromium 31), as long as encoding is set to UTF-8 or auto-detect. Alas, it doesn't qualify under the stated rules ("program must consist entirely of printable ASCII characters"). :-( \$\endgroup\$ Commented Jan 5, 2014 at 16:37
  • \$\begingroup\$ I know, it was just for fun ;) \$\endgroup\$ Commented Jan 5, 2014 at 18:13
0
\$\begingroup\$

PowerShell, 220 byes = script:9 + archive:211

tar xOf t

Try it online!

The Powershell script to create the archive t (see TIO):

(
" _ _ _ _ _ _ _",
"| | | | ___| | | ___ __ _____ _ __| | __| | |",
"| |_| |/ _ \ | |/ _ \ \ \ /\ / / _ \| '__| |/ _` | |",
"| _ | __/ | | (_) | \ V V / (_) | | | | (_| |_|",
"|_| |_|\___|_|_|\___( ) \_/\_/ \___/|_| |_|\__,_(_)",
" |/"
) | Set-Content f -Force
tar zcfo t f
Get-ChildItem t # output info about archive size
answered Jul 21, 2019 at 3:47
\$\endgroup\$
1
  • \$\begingroup\$ Isn't the archive non-printable? \$\endgroup\$ Commented Sep 28, 2022 at 22:30
0
\$\begingroup\$

Fig, \274ドル\log_{256}(96)\approx\$ 225.535 bytes

Dr_tem[82]\r-reIX3vb/pBNI9@xbV1?^csytMxrA)YVtY.5yfDryr#(K{bAe,YSkOIU9\|tet&RZF_n+!\;TlNE'T3OB{GGqqvpiP 61;Y#nh0^=vOX6@vxmixkmqp<&y<%;b?=|FG&!6*XI*<glXG,bt|0Kv`/lO;OEx7[`$vT4ljhkSGVaE'</\z{uF8L2E2yXU%r\Ws9F;cF4FXZVD}TL?qdxQ;slDX~lyO# K_+lFV52P-Io9a.7JuDaWJ/sAo,lCChg=5 P9^=[B

Try it online!

Boring text compression answer. Doesn't compress very well due to the compressor being much more optimized for words and spaces before words than characters. Fun fact: when designing Fig, I was considering making the compressor use RLE in the character case, but decided to do capitalization instead :(

answered Sep 28, 2022 at 22:34
\$\endgroup\$
0
\$\begingroup\$

tinylisp, 460 bytes

(d K disp
(d E(q((X)(i(e X 42)32(i(e X 62)41(i(e X 60)40 X
(d D(q((S)(i S(c(E(h S))(D(t S)))(
(d C(q((S)(string(D(chars S
(K(C(q *_***_******_*_*****************************_*****_*_
(K(C(q |*|*|*|*___|*|*|*___****__******_____**_*__|*|*__|*|*|
(K(C(q |*|_|*|/*_*\*|*|/*_*\***\*\*/\*/*/*_*\|*'__|*|/*_`*|*|
(K(C(q |**_**|**__/*|*|*<_>*|***\*V**V*/*<_>*|*|**|*|*<_|*|_|
(K(C(q |_|*|_|\___|_|_|\___<*>***\_/\_/*\___/|_|**|_|\__,_<_>
(K(C(q ********************|/

Try it online!

Basically hard-coded, with substitutions required for spaces and parens.

answered Apr 3 at 23:40
\$\endgroup\$

Your Answer

Draft saved
Draft discarded

Sign up or log in

Sign up using Google
Sign up using Email and Password

Post as a guest

Required, but never shown

Post as a guest

Required, but never shown

By clicking "Post Your Answer", you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.