# Introduction

On the 26th of August, 2017, Floyd Mayweather, Jr. will face up to Conor McGregor in a boxing match.

Both participants will receive the phenomenal amount of 100 million dollars!

Unfortunately, we do not have the money yet, but we can already prepare the big briefcase that will contain all the banknotes.

        _________________________
|                       |
|=======================================|
|       $$         $| |$         $$      |
|               $$| |$$$$| |_______________________________________|  The briefcase is composed of _,|,= and . It has a size of 41 characters in width (ignoring the newlines) and 6 in height (+2 for the handle). # Challenge Given no input, write a full program to output a 2D briefcase (see above). # Score This is , so the shortest solution (in bytes) wins. • I've changed the links to point to English Wikipedia since an overwhelming share of users speak English. – cat Jun 16, 2017 at 16:11 • The ultimate question: what is the width of the briefcase? Jun 17, 2017 at 1:55 • @cat Oops my bad Jun 17, 2017 at 14:37 • @RodrigoA.Pérez Already told in the question. 42 characters Jun 17, 2017 at 14:37 • @Weedoze Yes I know; the ultimate question... Jun 18, 2017 at 2:31 ## 18 Answers # Jelly, 92 75 bytes ⁽©Ḍṃ“_= ”x"“€Þ‘x2,6¤;"⁾_|x1,7¤z⁶ZUŒBY”“¢=Ḷ't3y&ḅḄȥıḍḄḌṀṡḂẓPḣṁQṘ½ɗ’BT+134¤¦  Try it online! ### How? Step 1. Build a list of the rows of the right half of an empty briefcase, ignoring trailing spaces: ⁽©Ḍṃ“_= ”x"“€Þ‘x2,6¤;"⁾_|x1,7¤ “_= ” - literal list of characters = "_= " ⁽©Ḍ - base 250 literal = 2674 ṃ - base decompress (2674 in base: 1='_', 2='=', 0=' ') - ...yields the list of characters: "_ = _" ¤ - nilad followed by link(s) as a nilad: “€Þ‘ - literal list of code page indexes = [12,20] 2,6 - literal list of numbers = [2,6] x - repeat -> [12,12,20,20,20,20,20,20] x - repeat -> ["_"*12, " "*12, "="*20, " "*20, ..., "_"*20] ¤ - nilad followed by link(s) as a nilad: ⁾_| - literal list of characters = "_|" 1,7 - literal list of numbers = [1,7] x - repeat -> list of characters "_|||||||" " - zip with the dyad: ; - concatenate -> ["_"+"_"*12, "|"+" "*12, ...]  Step 2: transform that into a whole empty briefcase: z⁶ZUŒBY ⁶ - literal space character z - transpose with filler (adds the "leading" spaces, to the 1st 2 rows) Z - transpose (back from columns to rows again) U - upend (reverse each row to make it a left-hand side of an empty briefcase) ŒB - bounce (add a reflection of each row with one central character) Y - join with new lines  Step 3: Show me the money! ”“¢=Ḷ't3y&ḅḄȥıḍḄḌṀṡḂẓPḣṁQṘ½ɗ’BT+134¤¦ ¦ - sparse application of: ” - literal '' character - ...to indexes: ¤ - nilad followed by link(s) as a nilad: “¢=Ḷ't3y&ḅḄȥıḍḄḌṀṡḂẓPḣṁQṘ½ɗ’ - base 250 literal = 1999171130867115278012045759181600763304793110829063794065408 B - convert to a binary list -> [1,0,0,1,1,1,1,1,0,0,1,1,1,1,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,1,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,1,1,1,1,0,0,1,1,1,1,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0] T - truthy indexes -> [1,4,5,6,7,8,11,12,13,14,15,18,26,39,43,46,50,53,57,60,61,62,66,67,68,85,88,92,95,99,102,105,106,107,110,127,130,131,132,133,134,137,138,139,140,141,144,152] 134 - literal 134 + - addition -> [135,138,139,140,141,142,145,146,147,148,149,152,160,173,177,180,184,187,191,194,195,196,200,201,202,219,222,226,229,233,236,239,240,241,244,261,264,265,266,267,268,271,272,273,274,275,278,286] - (that's where the s at!)  • Mmm... Beat me by 5 you beautiful beast. Jun 16, 2017 at 21:47 ## JavaScript (ES6), 187 184 bytes _=>70 78B B2B 9F33CDB AEFEFEF54B 9FEFEFF6DB 9F33CDB B1B.replace(/./g,c=>'__=$$$$||||$$$$'[n=+('0x'+c)].repeat(n>6?1:n?+'0005333'[n]||39:25)+' '.repeat(n-8?'0002632707307632'[n]:23))  ### How? The output is built using these 16 unique patterns: ID | Character | Repeated | Following spaces | Rendering ---+-----------+----------+------------------+------------------------------------------- 0 | _ | 25 | 0 | "_________________________" 1 | _ | 39 | 0 | "_______________________________________" 2 | = | 39 | 0 | "=======================================" 3 |  | 5 | 2 | "$$$$" 4 |  | 3 | 6 | "$$$" 5 |$     |     3    |         3        | "$$" 6 |  | 3 | 2 | "$$$" 7 | space | 1 | 7 | " " 8 | | | 1 | 23 | "| " 9 | | | 1 | 7 | "| " A | | | 1 | 3 | "| " B | | | 1 | 0 | "|" C |$     |     1    |         7        | "$" D |$     |     1    |         6        | "$" E |$     |     1    |         3        | "$" F |$     |     1    |         2        | "$"  ### Demo let f = _=>70 78B B2B 9F33CDB AEFEFEF54B 9FEFEFF6DB 9F33CDB B1B.replace(/./g,c=>'__= ||||'[n=+('0x'+c)].repeat(n>6?1:n?+'0005333'[n]||39:25)+' '.repeat(n-8?'0002632707307632'[n]:23)) console.log(f()) # 05AB1E, 80 bytes •Cā½œSÖ<ô’=-¾Ì„*нcF/“è∊αΔú9d:î₅•6B5¡.B€û»•H0αÅ±¼Āß8PβÁ19]× ôв•bvðy.;}4ÝJ"$ |=_"‡


Try it online!

# Explanation

The basic outline of the briefcase:

# 05AB1E, 41 bytes

•Cā½œSÖ<ô’=-¾Ì„*нcF/“è∊αΔú9d:î₅•6B5¡.B€û»


Try it online!

Sub-explanation explanation (part one):

I converted the overall design by cutting the design in half, replacing all characters with 2-6 and finally converting it to base 255 and reconstructing the shape using 5 as a newline delimiter.

•Cā½œSÖ<ô’=-¾Ì„*нcF/“è∊αΔú9d:î₅•  # Push the base-255 compressed number
6B                                # Convert it to  base-6 (the number of unique symbols)
5¡                              # Split on 5 (the newlines).
.B                            # Pad all elements with space to equal largest element length.
€û                          # For each element, mirror it.
»                         # Separate list with newlines.

77793946998265282127108152676813925695887415511783202442861719287811277


Is the number that's expressed in base 255, and the base 6 conversion of it is...

11111111444444444444511111111211111111111523333333333333333333525252525244444444444444444445


Then, splitting that on fives, mirroring and joining by newlines gets us...

111111114444444444444444444444411111111
111111112111111111111111111111211111111
233333333333333333333333333333333333332
2                                     2
2                                     2
2                                     2
2                                     2
244444444444444444444444444444444444442


Sub-explanation explanation (part two):

Starting to see where this is going? Next, I compress the inner pattern as a base-255 string:

•H0αÅ±¼Āß8PβÁ19]×
ôв•


Which is:

353343914082943027578174279006736773101445087


Convert to binary:

1111110110000011000001101111111011111110111011011101101110110001110001111111111101101110110111011011000110111111111110110000011000001101111111011111


For each of those characters, replace a space with the next character, iteratively:

111111114444444444444444444444411111111
111111112111111111111111111111211111111
233333333333333333333333333333333333332
211111101100000110000011011111110111112
211011101101110110111011000111000111112
211111101101110110111011011000110111112
211111101100000110000011011111110111112
244444444444444444444444444444444444442


Finally, replace the characters with what they're supposed to be.

0 = '$' 1 = ' ' 2 = '|' 3 = '=' 4 = '_' 4ÝJ"$ |=_"‡


For the loss:

        _______________________
|                     |
|=====================================|
|      $$         $| |$         $$     |
|              $$| |$$$$| |_____________________________________|  By compressing it as two separate patterns I save 20 bytes over: 7ºnF@É₄S¡‘nz'W›мλнbнžSÍõ₄óð½²Ç0Δεenë3aŽÖk∍&1ŒâÜ[¤öüuиSð±zαÛÊ¸q¥KÃĀ›Ć^ü¹ÉRKq®Ùì=Ö‚≠ØÖì¾!(Δ∍Ú  Which is: 111111114444444444444444444444411111111 111111112111111111111111111111211111111 233333333333333333333333333333333333332 211111101100000110000011011111110111112 211011101101110110111011000111000111112 211111101101110110111011011000110111112 211111101100000110000011011111110111112 244444444444444444444444444444444444442  Converted to base-10: 29962958783786255124710309272045448655717311098547870227488323781868803792449842685227629539722703574931794395923080776255103394202825327279714682601797290475465885089686540986020693577678744259173981845378875732421872  92 bytes plus the transliteration, which would total to about 105. ## Bubblegum, 55 bytes Probably possible to do some header removal magic, but I'm not as good as Dennis! 00000000: 5380 8278 5c80 0ba6 a246 013b a8e1 aab1 S..x\....F.;.... 00000010: 250e 0055 42f5 a800 1108 2028 9804 dc4c %..UB..... (...L 00000020: 2847 059d 0229 8790 6080 6a26 3a85 6c36 (G...)...j&:.l6 00000030: 49b6 c713 076a 00 I....j.  Try it online! • I get 55 as well, not a lot to work with there... Jun 16, 2017 at 19:45 # ///, 155 bytes /~/\/\///2/ ~3/2 ~6/33~7/6 ~1/____~4/__111~5/411___~#/=============~%/$$$~&/%$$~9/23232~@/| |~8/@72&2&276/ 75 7|33377@###8@339%3%6@792%268@45|  Try it online! I love it when /// can compete. Explanation: This works by defining common replacements like $$$$, then defining meta-replacements that include the original replacements. More in-depth: First of all, the only feature of /// is it's /pattern/replacement/ syntax and it's ability to use backslashes to escape other backslashes and forward-slashes. This information is important in the explanation. The first pattern/replacement in the code is for golfing purposes only (and detailed here). It replaces ~ with //, so the resulting code looks like this: /2/ //3/2 //6/33//7/6 //1/____//4/__111//5/411___//#/=============//%/$$$//&/%$$//9/23232//@/| |//8/@72&2&276/ 75 7|33377@###8@339%3%6@792%268@45|  Then a bunch of basic replacements are made. Some rely on others (meta-replacements), but the table of replacements looks like this (code wrapped in s): Pattern |Replacement ===================================== 2 |  ------------------------------------- 3 |  ------------------------------------- 6 |  ------------------------------------- 7 |  ------------------------------------- 1 |____ ------------------------------------- 4 |______________ ------------------------------------- 5 |_________________________ ------------------------------------- # |============= ------------------------------------- % |$$$ ------------------------------------- & |$
-------------------------------------
@                 ||
|| (Pipe, newline, pipe)
-------------------------------------


The meta-replacements here are things like /&/%$$/. This takes the already-existing replacement $$$ and uses it to define a new replacement $.

Then come the very large replacements. The first one replaces 9 with    and the second one replaces 8 with:

|
|       $$         $ Note the trailing spaces. Then all of these replacements are used in the following string:  75 7|33377@###8@3$39%3%6@79$2%2$68@45|


To get the desired output.

• Wow, I want a more in-depth explanation. Jun 16, 2017 at 22:43
• @carusocomputing Done. Jun 16, 2017 at 23:22
• While this is a fascinating and great example of programming in ///, it turns out a naive encoding is only about 143 bytes Oct 5, 2022 at 15:10

# SOGL, 58 57 bytes

¹&‘┐4Ο"ε@»-⅜Η⁄№ν½7bč═⁴‘'⁴n{╥ι}¹54"~æαΟ9≠š:+VæΨT-⅟yu7‘'∑nž


Explanation:

¹&‘┐                            push 20 spaces
4Ο                          swap between the 20 spaces and "|" 9 times, resulting in "|                    |                    |                    |                    |"
"...‘                     push "        _____________        |            |====================ŗ____________________", with ŗ replaced with the string above
'⁴n                  split into chunks of length 21
{╥ι}¹             palendromize horizontally
"...‘      push the sign - "    $$         $$    $$  "
'∑n   split into chunks of length 30


Try it Here!

## 54 bytes (competing?)

¹&‘┐4Ο"ε@»-⅜Η⁄№ν½7bč═⁴‘'⁴n╥ι54"~æαΟ9≠š:+VæΨT-⅟yu7‘'∑nž


The command used here is ╥ - palendromize, which only worked on strings, but was documentated for arrays too. (currently it's only implemented on the online interpreter)
Try it Here!

# PHP, 117 bytes

I am sad that there is nothing shorter than the lazy approach - gzip the string and base64-encode it:

<?=gzinflate(base64_decode(U1CAgHhcACqvwAVj1ChgB3Bxrhpb4kANF0yPChCBAIJCSIDNBqtUgapEpVTADBUUlQpYVUKVYVVJwHacwYMKagA));


Custom compression: 188 bytes

for(;$c=" 6_777 6| 883| |=8899| | 5$  $3$3  $5$ 4|
| 1$1$  $1$  $1$  $1 1$1 4|
| 5 1 1  $2$ 4|
| 53  $3$ 5$4| |_8899|"[$i++];)echo+$c?str_pad($d,$c+1,$d):$d=$c;


168 164 159 152 151 bytes with an adaption of officialaimm´s idea:

The lines can be seen as a bitmap between a boundary character (spaces for the first two, pipe after that), with space as 0 and another character as 1.
Inverting lines 3 and 8 gave them a value 0, so I could shift all values by 6 bits.

The array contains the bitmaps (converted to base 34; but only 7 values - the 8th element is omitted, an empty element evaluates to 0 as well). Base 35 would work as well; but base 33 has longer values and base 36 would need one more value quoted.

The string contains the boundary, 0 and 1 characters in that order for each line (omitting the last character, because lines 3 and 8 need no 1 character, having no bit set).

for(;$i<8;)echo strtr(sprintf("b%039bb ",intval(["1g7em2",p3ob4,0,v839j,cm7f3d,sfxq9,v839j][+$i],34)<<6),b01,substr("  _  ||= | $|$| $|$|_",$i++*3));  Custom compression by Jörg, 159 156 bytes: <?=strtr("5 _2222 5 |555 | |===333333| |516161504$414141$$4$$0514141  6  051616150___222222|",["$| |","$  $",______,"======"," "," ","$$"]);  • I think this is better Try it online! Jun 17, 2017 at 10:56 • Sorry I have found a better way Try it online! Jun 17, 2017 at 11:21 • @JörgHülsermann: me too Jun 17, 2017 at 11:29 • could you change the order of sprintf and strtr to drop the echo? Jun 17, 2017 at 11:34 • @JörgHülsermann: No. I have to convert the number before replacing the binary digits. Jun 17, 2017 at 11:39 # Jelly, 114 bytes “£zḂİẹḋmẋ>zạṾʂṀAYnŀ67ŻḢkðṡẉHLV'²ṙæṠṆoPẸCÞƒṿÑḢƲp4ƊƘṂɠ5×ṗ²X³⁻%ẹṄÑỊWÐh.ẹƁɗṫ0ạṢṆ@Gị}xMJʠɠS"LṂÐ÷ṙḃ?ṄP9÷/⁵EṛṇD’ṃ“ ¶|=_  Try it online! # Braingolf, 267 bytes 764*.7,2-#&744742222222562222574474#&[# ][#_]# [# ]#|[# ]"| |"[#=]"| |"[# ]#,.[#]# .[#]" "[# ]#,[# ]"| |"[# ]#[# ]" "[# ]" "[# ]" "[#][# ][#][# ]"| |"[# ]" "[# ]" "[# ]#[# ]#,.[#]" "[# ]"| |"[# ]#,.[#]# .[#]" "[# ]#,[# ]"| |"[#_]#|&@  Try it online! So golfy... # Python 2, 221 205 197 196 193 bytes • Saved 16 Bytes: Compression changed from 16-base to 36-base • Saved 8 bytes: Use of a="6ZBRS533| " and b="70JYF0U7|" • Saved 1 byte: Switched from Python 3 to 2 • Saved 3 bytes: Removed a white-space and a pair of braces(after rearranging the string-replacement) a="6ZBRS533| " b="70JYF0U7|" for u in["6YKXAYYN _","6ZKFUZR3 |",b+"= ",a,"6JNFT2RJ| ","6ZFOPPKV| ",a,b+"_ "]:print u[-3]+bin(int(u[:-3],36))[2:].replace("1",u[-2]).replace("0",u[-1])+u[-3]  Try it online! ### Explanation: Each line is in a generic form of pup where p is a boundary character and u is a string with two unique characters(for each line) which can be represented by 1 and 0. For example, line 5 is: |$$$ $| It has | as boundary character and the middle string contains only and $. The middle string can be represented by:

111011101101110110111011000111000111111

Now this binary string can be represented by 36-base number:

6JNFT2RJ

We can represent all the lines by a definitive string along with the 36-base string, boundary character and the characters used in middle string as follows:

111111100000000000000000000000001111111  "6YKXAYYN  _"
111111101111111111111111111111101111111  "6ZKFUZR3  |"
111111111111111111111111111111111111111  "70JYF0U7|= "
111111101100000110000011011111110111111  "6ZBRS533| $" 111011101101110110111011000111000111111 "6JNFT2RJ|$"
111111101101110110111011011000110111111  "6ZFOPPKV| $" 111111101100000110000011011111110111111 "6ZBRS533|$"
111111111111111111111111111111111111111  "70JYF0U7|_ "


We can thus decompress the base-36 string (after extractcing it from the definitive string) to binary string, replace 1 and 0 by the characters(also obtained from the definitive string) used in the middle string and glue with boundary characters at both ends. Thus, required string is obtained.

• If you inverse the full lines, you can cut off the lowest 6 bits; that should save 5 bytes or so. Jun 17, 2017 at 11:35

# C, 415402 397 bytes

#define P(x)D(x,4,4)
#define S(r,c)i=r;j=c;
#define D(x,c,n)for(k=x+n;x<k;t[i][j]=c)++x;
t[8][41]={0};i,j,k;o(x){S(2,x)P(i)P(j)S(3,x)P(j)D(i,4,3)}f(){t[1][8]=t[1][32]=92;t[4][4]=4;S(0,7)D(j,63,25)S(1,0)D(i,92,6)D(j,63,39)S(2,0)D(j,29,39)S(1,40)D(i,92,6)S(2,9)P(i)o(12);o(19);S(2,26)P(i)i-=2;D(j,4,2)++i;D(j,4,3)--i;D(j,4,3)i-=2;P(i)for(i=0;i<8;++i,puts(t))for(j=0;j<41;)printf("%c",t[i][j++]+32);}


Try it online!

# Retina, 140137 129 bytes

-3 bytes thanks to @Neil


d
A2A
c
|¶|7A2AAAAA2AAAAA2A7A6|¶|
b
======
a
______
A
$\d+$*


Try it online!

|=$"‡  Try it online! • You can save bytes by expressing the inner and outer/inner patterns as separate entities and using replace to combine them iteratively. I only recently learned this tactic for reducing the base conversion byte-count when doing the periodic table challenge :). Bubblegum kills it on anything less than 3 inner patterns though, and this is only 1 :(. codegolf.stackexchange.com/a/126995/59376 Jun 16, 2017 at 22:40 • @carusocomputing Bubblegum even kils SOGL so not really worth it... Jun 17, 2017 at 8:06 # JavaScript (ES6), 177 166 bytes _=> 8_25 8| 23| |=39|${r='| 7$2$5 2$5 2$ 7$6|'} | 3$ ${s='3$ 2$3$ 2$'}3$ 2$3 3$3 6|
| 7$2$ ${s}2$3 2$6|${r}
|_39|.replace(/(.)(\d+)/g,(_,b,c)=>b.repeat(c))


The string holds a collection of the characters to display along with the number of times to repeat. If a character isn't repeated, the number of times can be omitted.

Repeated string runs are optimized by storing in the variables r and s.

Snippet:

f=
_=> 8_25
8| 23|
|=39|
${r='| 7$ 2$5 2$5 2$7$ 6|'}
| 3{s='3$2$ 3$2$ '}3$2$3 3$3 6| | 7$ 2{s}2$3 2$ 6|
\${r}
|_39|.replace(/(.)(\d+)/g,(_,b,c)=>b.repeat(c))

console.log(f());

# Python 2, 135 bytes

print'eNpTUICAeFwAKq/ABWPUKGAHcHGuGlviQA0XTI8KEIEAgkJIgM0Gq1SBqkSlVMAMFRSVClhVQpVhVUnA9njiQA0AtPhDOg=='.decode('base64').decode('zlib')


Try it online!

# Charcoal, 52 bytes

←×_²⁰↑⁵|×=²⁰↖↑←×_¹³↘↙|↓↷‖Ｏ”{“↷γαc7sa%}⦃Ｎ№Ｔ⊕ＶⅉＨ➙Ｕ₂＆ηy


Try it online! Link is to verbose version of code. Explanation:

←×_²⁰↑⁵|×=²⁰↖↑←×_¹³↘↙|


Print the left half of the briefcase.

↓↷


Prepare the cursor so that the compressed string can be printed directly after reflecting. (Putting the downward movement after the reflection or before the compressed string changes their meaning.)

‖Ｏ


Reflect to complete the briefcase.

”{“↷γαc7sa%}⦃Ｎ№Ｔ⊕ＶⅉＨ➙Ｕ₂＆ηy


Print the amount as a compressed string. (Sadly this was the shortest approach, as otherwise the M consumed too many bytes.)

{iii}iicccccccc{iiiiii}iii{cc}ccccc{{d}ii}dddddc{ii}iicccccccc{{i}d}iic{{d}i}dd{cc}ccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{dddddd}ddd{cc}{c}ccccccccc{iiiiii}iiic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccccccciiiicddddcciiiicccccddddcciiiicccccddddcciiiicddddccccccciiiicddddcccccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccciiiicddddccciiiicddddcciiiicddddccciiiicddddcciiiicddddccciiiicddddcciiiicccddddccciiiicccddddcccccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccccccciiiicddddcciiiicddddccciiiicddddcciiiicddddccciiiicddddcciiiicddddcciiiicccddddcciiiicddddcccccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccccccciiiicddddcciiiicccccddddcciiiicccccddddcciiiicddddccccccciiiicddddcccccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{ddd}i{cc}{c}ccccccccc{iii}dc