Einführung

Am 26. August 2017 Floyd Mayweather Jr. wird stellen Conor McGregor in einem Boxkampf.

Beide Teilnehmer erhalten die phänomenale Summe von 100 Millionen Dollar!

Leider haben wir das Geld noch nicht, aber wir können bereits die große Aktentasche vorbereiten, die alle Banknoten enthalten wird.

        _________________________
        |                       |
|=======================================|
|       $  $$$$$  $$$$$  $       $      |
|   $   $  $   $  $   $  $$$   $$$      |
|       $  $   $  $   $  $  $$$  $      |
|       $  $$$$$  $$$$$  $       $      |
|_______________________________________|

Die Aktentasche ist aus _, |, =und $.

Es hat eine Breite von 41 Zeichen (ohne Berücksichtigung der Zeilenumbrüche) und eine Höhe von 6 Zeichen (+2 für das Handle).

Herausforderung

Wenn Sie keine Eingabe machen, schreiben Sie ein vollständiges Programm, um einen 2D-Aktenkoffer auszugeben (siehe oben).

Ergebnis

Das ist Code-Golf , also gewinnt die kürzeste Lösung (in Bytes).

Bubblegum, 55 Bytes

Wahrscheinlich ist es möglich, Header zu entfernen, aber ich bin nicht so gut wie 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.

Probieren Sie es online!

Jelly ,  92  75 Bytes

⁽©Ḍṃ“_= ”x"“€Þ‘x2,6¤;"⁾_|x1,7¤z⁶ZUŒBY”$“¢=Ḷ't3y&ḅḄȥıḍḄḌṀṡḂẓPḣṁQṘ½ɗ’BT+134¤¦

Probieren Sie es online!

Wie?

Schritt 1. Erstellen Sie eine Liste der Zeilen in der rechten Hälfte eines leeren Aktenkoffers und ignorieren Sie nachfolgende Leerzeichen:

⁽©Ḍṃ“_= ”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, ...]

Schritt 2: Verwandle das in eine leere Aktentasche:

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

Schritt 3: Zeigen Sie mir das Geld!

”$“¢=Ḷ'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!)

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

Wie?

Die Ausgabe wird anhand dieser 16 eindeutigen Muster erstellt:

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"$ |=_"‡

Probieren Sie es online!

Erläuterung

Die Grundzüge der Aktentasche:

05AB1E , 41 Bytes

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

Probieren Sie es online!

Erklärung der Untererklärung (erster Teil):

Ich habe das Gesamtdesign konvertiert, indem ich das Design in zwei 5Hälften geschnitten , alle Zeichen durch 2-6 ersetzt und es schließlich in Basis 255 konvertiert und die Form unter Verwendung eines Trennzeichens für Zeilenumbrüche rekonstruiert habe.

•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

Ist die Zahl, die in Basis 255 ausgedrückt wird, und die Basis 6-Konvertierung davon ist ...

11111111444444444444511111111211111111111523333333333333333333525252525244444444444444444445

Wenn wir das dann auf fünf aufteilen, spiegeln und durch Zeilenumbrüche verbinden, erhalten wir ...

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

Erklärung zur Untererklärung (Teil 2):

Beginnen Sie zu sehen, wohin das führt? Als nächstes komprimiere ich das innere Muster als Base-255-String:

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

Welches ist:

353343914082943027578174279006736773101445087

In Binär umwandeln:

1111110110000011000001101111111011111110111011011101101110110001110001111111111101101110110111011011000110111111111110110000011000001101111111011111

Ersetzen Sie für jedes dieser Zeichen ein Leerzeichen durch das nächste Zeichen, und zwar iterativ:

111111114444444444444444444444411111111
111111112111111111111111111111211111111
233333333333333333333333333333333333332
211111101100000110000011011111110111112
211011101101110110111011000111000111112
211111101101110110111011011000110111112
211111101100000110000011011111110111112
244444444444444444444444444444444444442

Schließlich ersetzen Sie die Zeichen durch das, was sie sein sollen.

0 = '$'
1 = ' '
2 = '|'
3 = '='
4 = '_'

4ÝJ"$ |=_"‡

Für den Verlust:

        _______________________        
        |                     |        
|=====================================|
|      $  $$$$$  $$$$$  $       $     |
|  $   $  $   $  $   $  $$$   $$$     |
|      $  $   $  $   $  $  $$$  $     |
|      $  $$$$$  $$$$$  $       $     |
|_____________________________________|

Durch Komprimieren als zwei separate Muster spare ich 20 Bytes ein:

7ºnF@É₄S¡‘nz'W›мλнbнžSÍõ₄óð½²Ç0Δεenë3aŽÖk∍&1ŒâÜ[¤öüuиSð±zαÛʸq¥KÃĀ›Ć^ü¹ÉRKq®Ùì=Ö‚≠ØÖì¾!(Δ∍Ú

Welches ist:

111111114444444444444444444444411111111
111111112111111111111111111111211111111
233333333333333333333333333333333333332
211111101100000110000011011111110111112
211011101101110110111011000111000111112
211111101101110110111011011000110111112
211111101100000110000011011111110111112
244444444444444444444444444444444444442

Umgerechnet auf Basis 10:

29962958783786255124710309272045448655717311098547870227488323781868803792449842685227629539722703574931794395923080776255103394202825327279714682601797290475465885089686540986020693577678744259173981845378875732421872

92 Bytes plus die Transliteration, was ungefähr 105 ergibt.

SOGL , 58 57 Bytes

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

Erläuterung:

¹&‘┐                            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

Probieren Sie es hier aus!

54 Bytes (im Wettbewerb? )

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

Der hier verwendete Befehl ist ╥- palendromize, der nur für Zeichenfolgen funktioniert, aber auch für Arrays dokumentiert wurde . (Derzeit ist es nur im Online-Interpreter implementiert.)
Probieren Sie es hier aus!

PHP, 117 Bytes

Ich bin traurig, dass nichts kürzer ist als der träge Ansatz - gzip den String und base64-encodiere ihn:

<?=gzinflate(base64_decode(U1CAgHhcACqvwAVj1ChgB3Bxrhpb4kANF0yPChCBAIJCSIDNBqtUgapEpVTADBUUlQpYVUKVYVVJwHacwYMKagA));

Benutzerdefinierte Komprimierung: 188 Byte

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 mit einer Adaption von officialaimms Idee :

Die Linien können als Bitmap zwischen einem Begrenzungszeichen (Leerzeichen für die ersten beiden, Pipe danach) mit Leerzeichen als 0und einem anderen Zeichen als gesehen werden 1.
Das Invertieren der Zeilen 3 und 8 gab ihnen einen Wert 0, so dass ich alle Werte um 6 Bits verschieben konnte.

Das Array enthält die Bitmaps (konvertiert in Basis 34; aber nur 7 Werte - das 8. Element wird weggelassen, ein leeres Element wird ebenfalls ausgewertet 0). Basis 35 würde auch funktionieren; Die Basis 33 hat jedoch längere Werte, und die Basis 36 würde einen weiteren angegebenen Wert benötigen.

Die Zeichenfolge enthält die Begrenzung 0und die 1Zeichen in dieser Reihenfolge für jede Zeile (wobei das letzte Zeichen weggelassen wird, da für die Zeilen 3 und 8 kein 1Zeichen erforderlich ist und kein Bit gesetzt ist).

for(;$i<8;)echo strtr(sprintf("b%039bb
",intval(["1g7em2",p3ob4,0,v839j,cm7f3d,sfxq9,v839j][+$i],34)<<6),b01,substr("  _  ||= | $| $| $| $|_",$i++*3));

Benutzerdefinierte Komprimierung von Jörg, 159 156 Bytes :

<?=strtr("5 _2222
5 |555  |
|===333333|
|516161504$414141$$4$$0514141  6  051616150___222222|",["$      |
|","$  $",______,"======","   ","       ","$$$"]);

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’ṃ“ ¶|=$_

Probieren Sie es online!

Braingolf , 267 Bytes

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

Probieren Sie es online!

So golfen ...

/// 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|

Probieren Sie es online!

Ich liebe es, wenn /// mithalten kann.

Erläuterung:

Dies funktioniert, indem Sie allgemeine Ersetzungen wie $$$$$definieren und dann Meta-Ersetzungen definieren, die die ursprünglichen Ersetzungen enthalten.

Ausführlicher:

Erstens ist das einzige Merkmal von /// die /pattern/replacement/Syntax und die Fähigkeit, Backslashes zu verwenden, um andere Backslashes und Forward-Slashes zu umgehen. Diese Information ist wichtig für die Erklärung.

Das erste Muster / der erste Ersatz im Code dient ausschließlich Golfzwecken (und wird hier beschrieben ). Sie ersetzt ~mit //, so dass die resultierende Code sieht wie folgt aus :

/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|

Dann werden einige grundlegende Ersetzungen vorgenommen. Einige stützen sich auf andere (Meta-Ersetzungen), aber die Ersetzungstabelle sieht folgendermaßen aus (Code in `s):

Pattern             |Replacement
=====================================
`2`                 |`  `
-------------------------------------
`3`                 |`   `
-------------------------------------
`6`                 |`      `
-------------------------------------
`7`                 |`       `
-------------------------------------
`1`                 |`____`
-------------------------------------
`4`                 |`______________`
-------------------------------------
`5`                 |`_________________________`
-------------------------------------
`#`                 |`=============`
-------------------------------------
`%`                 |`$$$`
-------------------------------------
`&`                 |`$$$$$`
-------------------------------------
`@`                 |`|
                    ||` (Pipe, newline, pipe)
-------------------------------------

Die Meta-Ersetzungen hier sind Dinge wie /&/%$$/. Dabei wird die bereits vorhandene Ersetzung $$$verwendet, um eine neue Ersetzung zu definieren $$$$$.

Dann kommen die sehr großen Ersetzungen. Der erste ersetzt 9mit $ $ $ $ $ $und der zweite ersetzt 8mit:

|
|       $  $$$$$  $$$$$  $       $      

Beachten Sie die nachstehenden Leerzeichen.

Dann werden alle diese Ersetzungen in der folgenden Zeichenfolge verwendet:

 75
 7|33377@###8@3$39%3%6@79$2%2$68@45|

Um die gewünschte Ausgabe zu erhalten.

Python 2 , 221 205 197 196 193 Bytes

• Gespeicherte 16 Bytes: Die Komprimierung wurde von 16 auf 36 geändert
• 8 Bytes gespeichert: Verwendung von a="6ZBRS533| $"undb="70JYF0U7|"
• 1 Byte gespeichert: Von Python 3 auf 2 umgestellt
• Gespeicherte 3 Bytes: Leerzeichen und ein Paar geschweifte Klammern entfernt (nach Neuanordnung des String-Ersatzes)

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]

Probieren Sie es online!

Erläuterung:

Jede Zeile hat eine generische Form von pupwobei pein Begrenzungszeichen und u eine Zeichenfolge mit zwei eindeutigen Zeichen (für jede Zeile) ist, die durch 1 und 0 dargestellt werden können. Beispiel: Zeile 5 ist:

| $ $ $ $ $ $ $$$ $$$ |

Es hat | als Grenzzeichen und die mittlere Zeichenfolge enthält nur und $. Die mittlere Zeichenfolge kann dargestellt werden durch:

111011101101110110111011000111000111111

Jetzt kann diese Binärzeichenfolge durch eine Zahl mit 36 ​​Basen dargestellt werden:

6JNFT2RJ

Wir können alle Zeilen durch eine definitive Zeichenfolge zusammen mit der Zeichenfolge mit 36 ​​Basen, dem Begrenzungszeichen und den in der mittleren Zeichenfolge verwendeten Zeichen wie folgt darstellen:

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

Wir können also die Base-36-Zeichenkette (nachdem wir sie aus der endgültigen Zeichenkette extrahiert haben) in eine binäre Zeichenkette dekomprimieren, 1 und 0 durch die Zeichen (die auch aus der endgültigen Zeichenkette stammen) ersetzen und an beiden Enden mit Begrenzungszeichen kleben . Somit wird die erforderliche Zeichenfolge erhalten.

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

Probieren Sie es online!

Retina , 140 137 129 Bytes

-3 Bytes dank @Neil

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

Probieren Sie es online!

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++);}

Probieren Sie es online!

05AB1E , 121 Byte

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

Probieren Sie es online!

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

Die Zeichenfolge enthält eine Sammlung der anzuzeigenden Zeichen sowie die Anzahl der Wiederholungen. Wenn ein Zeichen nicht wiederholt wird, kann die Anzahl weggelassen werden.

Wiederholte Stringläufe werden durch Speichern in den Variablen rund optimiert 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')

Probieren Sie es online!

Holzkohle , 52 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

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

Drucken Sie die linke Hälfte der Aktentasche.

↓↷

Bereiten Sie den Cursor so vor, dass die komprimierte Zeichenfolge direkt nach dem Reflektieren gedruckt werden kann. (Wenn Sie die Abwärtsbewegung nach der Reflektion oder vor der komprimierten Zeichenfolge platzieren, ändert sich ihre Bedeutung.)

‖Ｏ

Überlege, um die Aktentasche zu vervollständigen.

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

Gibt den Betrag als komprimierte Zeichenfolge aus. (Leider war dies der kürzeste Ansatz, da sonst Mzu viele Bytes verbraucht werden.)