Mayweather vs McGregor: prepara el premio en efectivo

16

Introducción

El 26 de agosto de 2017, Floyd Mayweather, Jr. se enfrentará a Conor McGregor en un combate de boxeo.

¡Ambos participantes recibirán la increíble cantidad de 100 millones de dólares!

Desafortunadamente, todavía no tenemos el dinero, pero ya podemos preparar el gran maletín que contendrá todos los billetes.

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

El maletín se compone de _, |, =y$ .

Tiene un tamaño de 41 caracteres de ancho (ignorando las nuevas líneas) y 6 de alto (+2 para el identificador).

Desafío

Sin entrada, escriba un programa completo para generar un maletín 2D (ver arriba).

Puntuación

Este es el código de golf , por lo que gana la solución más corta (en bytes).

code-golf ascii-art kolmogorov-complexity Weedoze
fuente
55
He cambiado los enlaces para que apunten a Wikipedia en inglés, ya que una gran cantidad de usuarios habla inglés.
gato
La última pregunta: ¿cuál es el ancho del maletín?
Rodrigo A. Pérez
@cat Oops my bad
Weedoze
@ RodrigoA.Pérez Ya lo conté en la pregunta. 42 caracteres
Weedoze
@Weedoze Sí, lo sé; la pregunta final ...
Rodrigo A. Pérez

Respuestas:

5

Chicle, 55 bytes

Probablemente sea posible hacer algo de magia de eliminación de encabezado, ¡pero no soy tan bueno como 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.

Pruébalo en línea!

Dom Hastings
fuente
1
Tengo 55 también, no hay mucho para trabajar allí ...
Alex Howansky
7

Gelatina ,  92  75 bytes

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

Pruébalo en línea!

¿Cómo?

Paso 1. Construya una lista de las filas de la mitad derecha de un maletín vacío, ignorando los espacios finales:

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

Paso 2: transforma eso en un maletín vacío completo:

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

Paso 3: ¡Muéstrame el dinero!

”$“¢=Ḷ'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!)
Jonathan Allan
fuente
Mmm ... golpéame por 5, bella bestia
Magic Octopus Urn
7

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

¿Cómo?

La salida se construye utilizando estos 16 patrones únicos:

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        | "$  "

Manifestación

Mostrar fragmento de código

Arnauld
fuente
6

05AB1E , 80 bytes

•Cā½œSÖ<ô’=-¾Ì„*нcF/“è∊αΔú9d:î₅•6B5¡.B€û»•H0αű¼Āß8PβÁ19]×
ôв•bvðy.;}4ÝJ"$ |=_"‡

Pruébalo en línea!

Explicación

El esquema básico del maletín:

05AB1E , 41 bytes

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

Pruébalo en línea!

Explicación de la sub explicación (primera parte):

Convertí el diseño general cortando el diseño a la mitad, reemplazando todos los caracteres con 2-6 y finalmente convirtiéndolo en base 255 y reconstruyendo la forma usando 5como delimitador de nueva línea.

•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

Es el número que se expresa en la base 255, y la conversión de la base 6 es ...

11111111444444444444511111111211111111111523333333333333333333525252525244444444444444444445

Luego, dividir eso en cinco, reflejar y unirse con nuevas líneas nos hace ...

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

Explicación de la subexplicación (segunda parte):

¿Comienza a ver a dónde va esto? A continuación, comprimo el patrón interno como una cadena base-255:

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

Cual es:

353343914082943027578174279006736773101445087

Convierte a binario:

1111110110000011000001101111111011111110111011011101101110110001110001111111111101101110110111011011000110111111111110110000011000001101111111011111

Para cada uno de esos caracteres, reemplace un espacio con el siguiente carácter, iterativamente:

111111114444444444444444444444411111111
111111112111111111111111111111211111111
233333333333333333333333333333333333332
211111101100000110000011011111110111112
211011101101110110111011000111000111112
211111101101110110111011011000110111112
211111101100000110000011011111110111112
244444444444444444444444444444444444442

Finalmente, reemplaza los personajes con lo que se supone que son.

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

4ÝJ"$ |=_"‡

Por la pérdida:

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

Al comprimirlo como dos patrones separados, ahorro 20 bytes en:

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

Cual es:

111111114444444444444444444444411111111
111111112111111111111111111111211111111
233333333333333333333333333333333333332
211111101100000110000011011111110111112
211011101101110110111011000111000111112
211111101101110110111011011000110111112
211111101100000110000011011111110111112
244444444444444444444444444444444444442

Convertido a base-10:

29962958783786255124710309272045448655717311098547870227488323781868803792449842685227629539722703574931794395923080776255103394202825327279714682601797290475465885089686540986020693577678744259173981845378875732421872

92 bytes más la transliteración, que sumaría aproximadamente 105.

Urna de pulpo mágico
fuente
3

SOGL , 58 57 bytes

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

Explicación:

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

Pruébalo aquí!

54 bytes ( ¿compitiendo? )

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

El comando utilizado aquí es ╥- palendromize, que solo funcionaba en cadenas, pero también estaba documentado para matrices . (actualmente solo se implementa en el intérprete en línea) ¡
Pruébelo aquí!

dzaima
fuente
3

PHP, 117 bytes

Me entristece que no haya nada más corto que el enfoque perezoso: gzip la cadena y codifíquelo en base64:

<?=gzinflate(base64_decode(U1CAgHhcACqvwAVj1ChgB3Bxrhpb4kANF0yPChCBAIJCSIDNBqtUgapEpVTADBUUlQpYVUKVYVVJwHacwYMKagA));

Compresión personalizada: 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 con una adaptación de la idea de officialaimm :

Las líneas pueden verse como un mapa de bits entre un carácter de límite (espacios para los dos primeros, canalización después de eso), con espacio como 0 y otro carácter como 1.
Invertir las líneas 3 y 8 les dio un valor0 , por lo que podría cambiar todos los valores en 6 bits.

La matriz contiene los mapas de bits (convertidos a base 34; pero solo 7 valores: el octavo elemento se omite, un elemento vacío también se evalúa 0). Base 35 también funcionaría; pero la base 33 tiene valores más largos y la base 36 necesitaría un valor más citado.

La cadena contiene el límite 0y los 1caracteres en ese orden para cada línea (omitiendo el último carácter, porque las líneas 3 y 8 no necesitan 1caracteres, ya que no tienen ningún conjunto de bits).

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

Compresión personalizada por Jörg, 159156 bytes :

<?=strtr("5 _2222
5 |555  |
|===333333|
|516161504$414141$$4$$0514141  6  051616150___222222|",["$      |
|","$  $",______,"======","   ","       ","$$$"]);
Titus
fuente
1
Creo que esto es mejor ¡ Pruébalo en línea!
Jörg Hülsermann
1
Lo siento, he encontrado una mejor manera ¡ Pruébalo en línea!
Jörg Hülsermann
@ JörgHülsermann: yo también
Titus
¿podría cambiar el orden de sprintf y strtr para soltar el eco?
Jörg Hülsermann
@ JörgHülsermann: No. Tengo que convertir el número antes de reemplazar los dígitos binarios.
Titus
2

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

Pruébalo en línea!

Erik el Outgolfer
fuente
2

Braingolf , 267 bytes

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

Pruébalo en línea!

Tan golfista ...

Skidsdev
fuente
2

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

Pruébalo en línea!

Me encanta cuando /// puedo competir.

Explicación:

Esto funciona definiendo reemplazos comunes como $$$$$ , luego definiendo meta-reemplazos que incluyen los reemplazos originales.

Más en profundidad:

En primer lugar, la única característica de /// es su /pattern/replacement/sintaxis y su capacidad de usar barras diagonales inversas para escapar de otras barras diagonales inversas y barras diagonales. Esta información es importante en la explicación.

El primer patrón / reemplazo en el código es solo para fines de golf (y se detalla aquí ). Se reemplaza ~con //, por lo que el código resultante se ve así:

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

Luego se hacen un montón de reemplazos básicos. Algunos confían en otros (meta-reemplazos), pero la tabla de reemplazos se ve así (código envuelto en `s):

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

Los meta-reemplazos aquí son cosas como /&/%$$/. Esto toma el reemplazo ya existente $$$y lo usa para definir un nuevo reemplazo$$$$$ .

Luego vienen los reemplazos muy grandes. El primero reemplaza 9con $ $ $ $ $ $y el segundo reemplaza 8con:

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

Tenga en cuenta los espacios finales.

Luego, todos estos reemplazos se utilizan en la siguiente cadena:

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

Para obtener la salida deseada.

Camarada SparklePony
fuente
Wow, quiero una explicación más profunda.
Magic Octopus Urn
@carusocomputing Hecho.
Camarada SparklePony
2

Python 2 , 221 205 197 196 193 bytes

  • 16 bytes guardados: la compresión cambió de 16 bases a 36 bases
  • 8 bytes guardados: uso de a="6ZBRS533| $" yb="70JYF0U7|"
  • 1 byte guardado: se cambió de Python 3 a 2
  • Guardado 3 bytes: se eliminó un espacio en blanco y un par de llaves (después de reorganizar el reemplazo de la cadena)
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]

Pruébalo en línea!

Explicación:

Cada línea está en una forma genérica de pupdonde pes un carácter de límite yu es una cadena con dos caracteres únicos (para cada línea) que se pueden representar con 1 y 0. Por ejemplo, la línea 5 es:

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

Tiene | como carácter de límite y la cadena central contiene solo y $. La cadena del medio se puede representar por:

111011101101110110111011000111000111111

Ahora esta cadena binaria se puede representar con un número de 36 bases:

6JNFT2RJ

Podemos representar todas las líneas mediante una cadena definitiva junto con la cadena de 36 bases, el carácter de límite y los caracteres utilizados en la cadena central de la siguiente manera:

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

Por lo tanto, podemos descomprimir la cadena base 36 (después de extraerla de la cadena definitiva) a una cadena binaria, reemplazar 1 y 0 por los caracteres (también obtenidos de la cadena definitiva) utilizados en la cadena central y pegar con caracteres de límite en ambos extremos . Por lo tanto, se obtiene la cadena requerida.

officialaimm
fuente
1
Si invierte las líneas completas, puede cortar los 6 bits más bajos; eso debería ahorrar 5 bytes más o menos.
Titus
2

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

Pruébalo en línea!

Steadybox
fuente
2

Retina , 140 137 129 bytes

-3 bytes gracias a @Neil


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

Pruébalo en línea!

ovs
fuente
Como no estás usando los 1s para nada más, ¿no puedes escribir $*<space>directamente?
Neil
2

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

Pruébalo en línea!

cleblanc
fuente
1

05AB1E , 121 bytes

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

Pruébalo en línea!

Erik el Outgolfer
fuente
Puede guardar bytes expresando los patrones internos y externos / internos como entidades separadas y utilizando el reemplazo para combinarlos iterativamente. Hace poco aprendí esta táctica para reducir el recuento de bytes de conversión base al hacer el desafío de la tabla periódica :). Sin embargo, Bubblegum lo mata en menos de 3 patrones internos, y esto es solo 1 :(. Codegolf.stackexchange.com/a/126995/59376
Urna de pulpo mágico
@carusocomputing Bubblegum incluso mata a SOGL, así que realmente no vale la pena ...
Erik the Outgolfer
1

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

La cadena contiene una colección de caracteres para mostrar junto con la cantidad de veces que se repetirá. Si un personaje no se repite, se puede omitir el número de veces.

Las ejecuciones de cadena repetidas se optimizan almacenando en las variables ry s.

Retazo:

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

Rick Hitchcock
fuente
0

Python 2 , 135 bytes

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

Pruébalo en línea!

mdahmoune
fuente
0

Carbón , 52 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

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

Imprime la mitad izquierda del maletín.

↓↷

Prepare el cursor para que la cadena comprimida se pueda imprimir directamente después de reflejar. (Poner el movimiento hacia abajo después del reflejo o antes de que la cuerda comprimida cambie su significado).

‖Ｏ

Reflexiona para completar el maletín.

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

Imprima la cantidad como una cadena comprimida. (Lamentablemente, este fue el enfoque más corto, ya que de lo contrario Mconsumió demasiados bytes).

Neil
fuente