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&OOGB$4:%`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!

  • Ok, I have to do this one in C... – Michael Dorgan Dec 29 '11 at 20:41

17 Answers 17

up vote 2 down vote accepted

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,(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('

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 '(_)'.

  • +1, very nice. You can save 2 chars by replacing print by say – Toto Dec 19 '11 at 13:04
  • @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? – han Dec 19 '11 at 13:47
  • The -E doesn't count in number of char. – Toto Dec 19 '11 at 14:04
  • 1
    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. – Ilmari Karonen Dec 21 '11 at 7:21
  • 2
    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. – Ilmari Karonen Dec 22 '11 at 2:29

Brainfuck - 862 characters:

>++++[<++++++++>-]>-----[<---->---]<+++>>--[<+>--]<---<<.>.<...>.<....
..>.<.>.<.............................>.<.....>.<.>.>>++++++++++.<.<<.
>>.<<.>>.<<.>>.<<.>...>.<<.>>.<<.>>.<<.>...<....>..<......>.....<..>.<
.>..>.<<.>>.<<.>..>.<<.>>.<<.>>.>.<.<<.>>.<.>.<<.>>.>>>-[<->+++++]<---
-.<<<<.>.<.>---.+++<.>>.<<.>>.>>.<<<<.>.<.>---.<...>.<.>.<.>>>>.<<<.<.
>>>>.<<<<.>>>>.<<<<.>+++.<.>---.>.<<.>>>>>>---[<+>+++++++]<++.<<<<+++.
.>.<<.>>.>>.<<<<.>.+.-<.>>.<<.>>.>.<.<<..>.<..>>.<<..>..>>>.<<<<.>>.<<
.>>.<<.>>>>>+.<<<<.>>>>+.<<<<<.>>.<<...>---.<.>------.<..>.<.>>>>.<<<<
.>>>>>-.<<<<+++++++++.>>>>+.<<<<<.>>.<<.>>.<<..>>.<<.>>.<<.>>>>>-.<<<<
.>.<<.>>.<.>.>.<.<.>.<<.>>.<.>.<---.+++...>.<.>.<.>.<---.+++...>>>>.<<
<<<.>>>>>+.<<<<<...>---.+++.>>>.<<<---.+++.>>>.<<<<.>---.+++...>>>.<<.
<.>.<<..>>.<.>.<---.+++..>>>>+++.<<<<.>>>>----.<<<<.>>>>+.<<.<<<......
..............>>.>>.<.
  • 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.) – Ilmari Karonen Dec 16 '11 at 1:03
  • 21
    How the heck did you write this in two hours? – Joey Adams Dec 16 '11 at 2:52
  • 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 – JBernardo Dec 16 '11 at 3:13
  • 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. – captncraig Dec 16 '11 at 5:26
  • @JBernardo, BF dev text generator gave code much bigger than this. It would take a much more complicated generator to beat this I think. – captncraig Dec 16 '11 at 5:28

Python (2.x), 194 characters

print'eNo9T8ENxCAMe5cp/DsqVco2fSH5BsnwZ4ccEIhxbAIgAK9KvDRwGBEjsSfJA6r2N7EISbmrpbLNKFRYOABaC6FAEYkPW/Ztm1t7Z1S3ydtHuV4ooolEV6vPyJ2XH8kGE7d9DAVMhFUte6h7xv5rxg8sf0Qc'.decode('base64').decode('zip')
  • 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 – daboross Mar 8 '14 at 5:36

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

:(

  • Save the space after the return, -1 char :) – pimvdb Dec 31 '11 at 11:32

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! :)

  • 4
    AKA “my scrollbar is longer than yours” – tzot Dec 16 '11 at 22:14
  • This solution can be golfed down to 254 characters. Do you mind if I edit in the shorter version? – han Dec 20 '11 at 19:40
  • @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 :) – tzot Dec 20 '11 at 20:36
  • 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. – han Dec 21 '11 at 17:52

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

  • 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. – Ilmari Karonen Dec 16 '11 at 14:16
  • OSX 5.3.6 works fine with the -r'=..'. does the php -r not count? It's included in my 189chars... – konsolenfreddy Dec 16 '11 at 15:32
  • 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 <?. – Ilmari Karonen Dec 16 '11 at 15:53

Bash, 199 196 193 characters

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

Close enough...

EDIT: Down to 193!

  • 1
    Nice. You could save three more chars by replacing gzip -d with zcat. – Ilmari Karonen Dec 16 '11 at 5:31
  • 3
    Using a where-string would save over echo. – Peter Taylor Dec 16 '11 at 13:39

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.

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.

  • 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. – Ilmari Karonen Dec 16 '11 at 5:34

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","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 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.

bash, 196 192

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

Pylongolf2, 300 bytes

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

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

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.

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.

  • 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"). :-( – Ilmari Karonen Jan 5 '14 at 16:37
  • I know, it was just for fun ;) – xem Jan 5 '14 at 18:13

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

Your Answer

 

By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.

Not the answer you're looking for? Browse other questions tagged or ask your own question.