16
\$\begingroup\$

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.

\$\endgroup\$
  • 5
    \$\begingroup\$ I've changed the links to point to English Wikipedia since an overwhelming share of users speak English. \$\endgroup\$ – cat Jun 16 '17 at 16:11
  • \$\begingroup\$ The ultimate question: what is the width of the briefcase? \$\endgroup\$ – Rodrigo A. Pérez Jun 17 '17 at 1:55
  • \$\begingroup\$ @cat Oops my bad \$\endgroup\$ – Weedoze Jun 17 '17 at 14:37
  • \$\begingroup\$ @RodrigoA.Pérez Already told in the question. 42 characters \$\endgroup\$ – Weedoze Jun 17 '17 at 14:37
  • \$\begingroup\$ @Weedoze Yes I know; the ultimate question... \$\endgroup\$ – Rodrigo A. Pérez Jun 18 '17 at 2:31

17 Answers 17

5
\$\begingroup\$

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!

\$\endgroup\$
  • 1
    \$\begingroup\$ I get 55 as well, not a lot to work with there... \$\endgroup\$ – Alex Howansky Jun 16 '17 at 19:45
7
\$\begingroup\$

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!)
\$\endgroup\$
  • \$\begingroup\$ Mmm... Beat me by 5 you beautiful beast. \$\endgroup\$ – Magic Octopus Urn Jun 16 '17 at 21:47
7
\$\begingroup\$

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())

\$\endgroup\$
6
\$\begingroup\$

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.

\$\endgroup\$
3
\$\begingroup\$

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
                   54        ž  at coordinates (5;4) place the sign in the briefcase

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!

\$\endgroup\$
3
\$\begingroup\$

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|
| 5$  $3  $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|",["$      |
|","$  $",______,"======","   ","       ","$$$"]);
\$\endgroup\$
  • 1
    \$\begingroup\$ I think this is better Try it online! \$\endgroup\$ – Jörg Hülsermann Jun 17 '17 at 10:56
  • 1
    \$\begingroup\$ Sorry I have found a better way Try it online! \$\endgroup\$ – Jörg Hülsermann Jun 17 '17 at 11:21
  • \$\begingroup\$ @JörgHülsermann: me too \$\endgroup\$ – Titus Jun 17 '17 at 11:29
  • \$\begingroup\$ could you change the order of sprintf and strtr to drop the echo? \$\endgroup\$ – Jörg Hülsermann Jun 17 '17 at 11:34
  • \$\begingroup\$ @JörgHülsermann: No. I have to convert the number before replacing the binary digits. \$\endgroup\$ – Titus Jun 17 '17 at 11:39
2
\$\begingroup\$

Jelly, 114 bytes

“£zḂİẹḋmẋ>zạṾʂṀAYnŀ67ŻḢkðṡẉHLV'²ṙæṠṆoPẸCÞƒṿÑḢƲp4ƊƘṂɠ5×ṗ²X³⁻%ẹṄÑỊWÐh.ẹƁɗṫ0ạṢṆ@Gị}xM`JʠɠS"LṂÐ÷ṙḃ?ṄP9÷/⁵EṛṇD’ṃ“ ¶|=$_

Try it online!

\$\endgroup\$
2
\$\begingroup\$

Braingolf, 267 bytes

764*.7,2-#&744742222222562222574474#&[# ][#_]#
[# ]#|[# ]"|
|"[#=]"|
|"[# ]#$,.[#$]# .[#$]"  $"[# ]#$,[# ]"|
|"[# ]#$[# ]"$  $"[# ]"$  $"[# ]"$  "[#$][# ][#$][# ]"|
|"[# ]"$  $"[# ]"$  $"[# ]#$[# ]#$,.[#$]"  $"[# ]"|
|"[# ]#$,.[#$]# .[#$]"  $"[# ]#$,[# ]"|
|"[#_]#|&@

Try it online!

So golfy...

\$\endgroup\$
2
\$\begingroup\$

///, 155 bytes

/~/\/\///2/  ~3/2 ~6/33~7/6 ~1/____~4/__111~5/411___~#/=============~%/$$$~&/%$$~9/$2$3$2$3$2~@/|
|~8/@7$2&2&2$7$6/ 75
 7|33377@###8@3$39%3%6@79$2%2$68@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/$2$3$2$3$2//@/|
|//8/@7$2&2&2$7$6/ 75
 7|33377@###8@3$39%3%6@79$2%2$68@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.

\$\endgroup\$
  • \$\begingroup\$ Wow, I want a more in-depth explanation. \$\endgroup\$ – Magic Octopus Urn Jun 16 '17 at 22:43
  • \$\begingroup\$ @carusocomputing Done. \$\endgroup\$ – Comrade SparklePony Jun 16 '17 at 23:22
2
\$\begingroup\$

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.

\$\endgroup\$
  • 1
    \$\begingroup\$ If you inverse the full lines, you can cut off the lowest 6 bits; that should save 5 bytes or so. \$\endgroup\$ – Titus Jun 17 '17 at 11:35
2
\$\begingroup\$

C, 415 402 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!

\$\endgroup\$
2
\$\begingroup\$

Retina, 140 137 129 bytes

-3 bytes thanks to @Neil


8aaaa_¶8|23|¶|bbbbbb===c3A3d3d3dAA3AAA6|¶|7d3d3d2AAd6caaaaaa___|
d
A2A
c
|¶|7A2AAAAA2AAAAA2A7A6|¶|
b
======
a
______
A
$
\d+
$* 

Try it online!

\$\endgroup\$
  • \$\begingroup\$ Since you're not using the 1s for anything else, can you not write $*<space> directly? \$\endgroup\$ – Neil Jun 16 '17 at 14:32
2
\$\begingroup\$

C (gcc), 388 386 302 bytes

char*r="8 24_08 1|22 1|01|37=1|01|6 1$2 5$2 5$2 1$7 1$5 1|01|2 1$3 1$2 1$3 1$2 1$3 1$2 3$3 3$5 1|01|6 1$2 1$3 1$2 1$3 1$2 1$2 3$2 1$5 1|01|6 1$2 5$2 5$2 1$7 1$5 1|01|37_1|";char d[9];main(i){do{if(*r==48)puts(""),r++;for(i=0;isdigit(*r);d[i++]=*r++);for(d[i]=0,i=atoi(d);i--;putchar(*r));}while(*r++);}

Try it online!

\$\endgroup\$
1
\$\begingroup\$

05AB1E, 121 bytes

•?íLñ>ć£P¹ĀJδšlÔ@.ì@E'a‘2‡ΔÉ₅’Õ'8¾—Hú∊‹£ñ₂C*ƶ¬}ʒ³öG`ŒªKµδB₁вÑ(δüc›½ćˆ3αÂÝβ+Í‘]~é£42îĆ$Ÿ₅Ë!∊s₆L×ä5Uñ₁δǝβζ•6B•1’₃•" _
|=$"‡

Try it online!

\$\endgroup\$
  • \$\begingroup\$ 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 \$\endgroup\$ – Magic Octopus Urn Jun 16 '17 at 22:40
  • \$\begingroup\$ @carusocomputing Bubblegum even kils SOGL so not really worth it... \$\endgroup\$ – Erik the Outgolfer Jun 17 '17 at 8:06
1
\$\begingroup\$

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());

\$\endgroup\$
0
\$\begingroup\$

Python 2, 135 bytes

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

Try it online!

\$\endgroup\$
0
\$\begingroup\$

Charcoal, 52 bytes

←×_²⁰↑⁵|×=²⁰↖↑←×_¹³↘↙|↓↷‖O”{“↷γαc7sa%}⦃N№T⊕VⅉH➙U₂&η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.)

‖O

Reflect to complete the briefcase.

”{“↷γαc7sa%}⦃N№T⊕VⅉH➙U₂&ηy

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

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

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