introduction

Le 26 août 2017, Floyd Mayweather, Jr. affrontera Conor McGregor dans un match de boxe.

Les deux participants recevront le montant phénoménal de 100 millions de dollars!

Malheureusement, nous n'avons pas encore l'argent, mais nous pouvons déjà préparer la grande mallette qui contiendra tous les billets.

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

La mallette est composée de _, |, =et $.

Il a une taille de 41 caractères en largeur (en ignorant les sauts de ligne) et 6 en hauteur (+2 pour la poignée).

Défi

Sans aucune entrée, écrivez un programme complet pour sortir un porte-documents 2D (voir ci-dessus).

But

Il s'agit de code-golf , donc la solution la plus courte (en octets) l'emporte.

code-golf ascii-art kolmogorov-complexity Weedoze
la source

5

J'ai changé les liens pour pointer vers Wikipedia anglais depuis qu'une écrasante majorité d'utilisateurs parlent anglais.

cat

La question ultime: quelle est la largeur de la mallette?

Rodrigo A. Pérez

@cat Oops my bad

Weedoze

@ RodrigoA.Pérez Déjà dit dans la question. 42 personnages

Weedoze

@Weedoze Oui, je sais; l'ultime question ...

Rodrigo A. Pérez

5

Bubblegum, 55 octets

Probablement possible de faire de la magie de suppression d'en-tête, mais je ne suis pas aussi bon que 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.

Essayez-le en ligne!

Dom Hastings
la source

1

J'en ai 55 aussi, pas beaucoup avec qui travailler là-bas ...

Alex Howansky

7

Gelée , 92 75 octets

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

Essayez-le en ligne!

Comment?

Étape 1. Construisez une liste des rangées de la moitié droite d'une mallette vide, en ignorant les espaces de fin:

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

Étape 2: transformez cela en une mallette vide:

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

Étape 3: Montrez-moi l'argent!

”$“¢=Ḷ'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
la source

Mmm ... Battez-moi par 5 vous belle bête.

Magic Octopus Urn

7

JavaScript (ES6), 187 184 octets

_=>`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))

Comment?

La sortie est construite en utilisant ces 16 modèles uniques:

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

Démo

Afficher l'extrait de code

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

Expand snippet

Arnauld
la source

6

05AB1E , 80 octets

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

Essayez-le en ligne!

Explication

Les grandes lignes de la mallette:

05AB1E , 41 octets

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

Essayez-le en ligne!

Explication de la sous-explication (première partie):

J'ai converti la conception globale en coupant la conception en deux, en remplaçant tous les caractères par 2-6 et enfin en la convertissant en base 255 et en reconstruisant la forme en utilisant 5un délimiteur de nouvelle ligne.

•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

Est le nombre exprimé en base 255, et sa conversion en base 6 est ...

11111111444444444444511111111211111111111523333333333333333333525252525244444444444444444445

Ensuite, diviser cela sur cinq, mettre en miroir et rejoindre par des nouvelles lignes nous obtient ...

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

Explication de la sous-explication (deuxième partie):

Vous commencez à voir où cela va? Ensuite, je compresse le motif interne sous la forme d'une chaîne de base 255:

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

Lequel est:

353343914082943027578174279006736773101445087

Convertir en binaire:

1111110110000011000001101111111011111110111011011101101110110001110001111111111101101110110111011011000110111111111110110000011000001101111111011111

Pour chacun de ces caractères, remplacez un espace par le caractère suivant, de manière itérative:

111111114444444444444444444444411111111
111111112111111111111111111111211111111
233333333333333333333333333333333333332
211111101100000110000011011111110111112
211011101101110110111011000111000111112
211111101101110110111011011000110111112
211111101100000110000011011111110111112
244444444444444444444444444444444444442

Enfin, remplacez les personnages par ce qu'ils sont censés être.

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

4ÝJ"$ |=_"‡

Pour la perte:

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

En le compressant en deux modèles distincts, j'économise 20 octets sur:

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

Lequel est:

111111114444444444444444444444411111111
111111112111111111111111111111211111111
233333333333333333333333333333333333332
211111101100000110000011011111110111112
211011101101110110111011000111000111112
211111101101110110111011011000110111112
211111101100000110000011011111110111112
244444444444444444444444444444444444442

Converti en base 10:

29962958783786255124710309272045448655717311098547870227488323781868803792449842685227629539722703574931794395923080776255103394202825327279714682601797290475465885089686540986020693577678744259173981845378875732421872

92 octets plus la translittération, ce qui totaliserait environ 105.

Urne de poulpe magique
la source

3

SOGL , 58 57 octets

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

Explication:

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

Essayez-le ici!

54 octets (en compétition? )

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

La commande utilisée ici est ╥- palendromize, qui ne fonctionnait que sur les chaînes, mais était également documentée pour les tableaux . (actuellement, il n'est implémenté que sur l'interpréteur en ligne)
Essayez-le ici!

dzaima
la source

3

PHP, 117 octets

Je suis triste qu'il n'y ait rien de plus court que l'approche paresseuse - gzipez la chaîne et encodez en base64:

<?=gzinflate(base64_decode(U1CAgHhcACqvwAVj1ChgB3Bxrhpb4kANF0yPChCBAIJCSIDNBqtUgapEpVTADBUUlQpYVUKVYVVJwHacwYMKagA));

Compression personnalisée: 188 octets

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 octets avec une adaptation de l'idée officielle de l'aimaim :

Les lignes peuvent être vues comme un bitmap entre un caractère de frontière (espaces pour les deux premiers, pipe après cela), avec un espace comme 0et un autre caractère comme 1.
Inverser les lignes 3 et 8 leur a donné une valeur0 , donc j'ai pu décaler toutes les valeurs de 6 bits.

Le tableau contient les bitmaps (convertis en base 34; mais seulement 7 valeurs - le 8ème élément est omis, un élément vide est également évalué 0). La base 35 fonctionnerait également; mais la base 33 a des valeurs plus longues et la base 36 aurait besoin d'une valeur supplémentaire citée.

La chaîne contient la frontière 0et les 1caractères dans cet ordre pour chaque ligne (en omettant le dernier caractère, car les lignes 3 et 8 n'ont pas besoin de 1caractère, sans bit défini).

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

Compression personnalisée par Jörg, ~~159~~ 156 octets :

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

Titus
la source

1

Je pense que c'est mieux Essayez-le en ligne!

Jörg Hülsermann

1

Désolé, j'ai trouvé un meilleur moyen Essayez-le en ligne!

Jörg Hülsermann

@ JörgHülsermann: moi aussi

Titus

pourriez-vous changer l'ordre de sprintf et strtr pour supprimer l'écho?

Jörg Hülsermann

@ JörgHülsermann: Non. Je dois convertir le nombre avant de remplacer les chiffres binaires.

Titus

2

Gelée , 114 octets

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

Essayez-le en ligne!

Erik le Outgolfer
la source

2

Braingolf , 267 octets

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

Essayez-le en ligne!

Alors golfy ...

Skidsdev
la source

2

/// , 155 octets

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

Essayez-le en ligne!

J'adore quand /// peut rivaliser.

Explication:

Cela fonctionne en définissant des remplacements communs comme $$$$$ , puis en définissant des méta-remplacements qui incluent les remplacements d'origine.

Plus en profondeur:

Tout d'abord, la seule caractéristique de /// est sa /pattern/replacement/syntaxe et sa capacité à utiliser des barres obliques inverses pour échapper à d'autres barres obliques inverses et barres obliques. Ces informations sont importantes dans l'explication.

Le premier modèle / remplacement dans le code est uniquement à des fins de golf (et détaillé ici ). Il remplace ~par //, donc le code résultant ressemble à ceci:

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

Ensuite, un tas de remplacements de base sont effectués. Certains s'appuient sur d'autres (méta-remplacements), mais le tableau des remplacements ressemble à ceci (code enveloppé dans `s):

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

Les méta-remplacements ici sont des choses comme /&/%$$/. Cela prend le remplacement déjà existant $$$et l'utilise pour définir un nouveau remplacement$$$$$ .

Viennent ensuite les très gros remplacements. Le premier remplace 9par $ $ $ $ $ $et le second remplace 8par:

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

Notez les espaces de fin.

Tous ces remplacements sont ensuite utilisés dans la chaîne suivante:

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

Pour obtenir la sortie souhaitée.

Camarade SparklePony
la source

Wow, je veux une explication plus approfondie.

Magic Octopus Urn

@carusocomputing Done.

Camarade SparklePony

2

Python 2 , 221 205 197 196 193 octets

16 octets enregistrés: la compression est passée de 16 bases à 36 bases
8 octets enregistrés: utilisation de a="6ZBRS533| $"etb="70JYF0U7|"
1 octet enregistré: basculé de Python 3 à 2
Enregistré 3 octets: Suppression d'un espace blanc et d'une paire d'accolades (après avoir réorganisé le remplacement de chaîne)

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]

Essayez-le en ligne!

Explication:

Chaque ligne est sous une forme générique pupoù pest un caractère frontière et u est une chaîne avec deux caractères uniques (pour chaque ligne) qui peuvent être représentés par 1 et 0. Par exemple, la ligne 5 est:

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

Il a | comme caractère de limite et la chaîne du milieu contient uniquement et $. La chaîne du milieu peut être représentée par:

111011101101110110111011000111000111111

Maintenant, cette chaîne binaire peut être représentée par un nombre de 36 bases:

6JNFT2RJ

Nous pouvons représenter toutes les lignes par une chaîne définitive avec la chaîne de 36 bases, le caractère de limite et les caractères utilisés dans la chaîne du milieu comme suit:

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

Nous pouvons ainsi décompresser la chaîne de base 36 (après l'avoir extraite de la chaîne définitive) en chaîne binaire, remplacer 1 et 0 par les caractères (également obtenus à partir de la chaîne définitive) utilisés dans la chaîne du milieu et coller avec des caractères de frontière aux deux extrémités . Ainsi, la chaîne requise est obtenue.

officialaimm
la source

1

Si vous inversez les lignes complètes, vous pouvez couper les 6 bits les plus bas; cela devrait économiser environ 5 octets.

Titus

2

C, 415 402 397 octets

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

Essayez-le en ligne!

Steadybox
la source

2

Retina , 140 137 129 octets

-3 octets grâce à @Neil


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

Essayez-le en ligne!

ovs
la source

Puisque vous n'utilisez pas le 1s pour autre chose, ne pouvez-vous pas écrire $*<space>directement?

Neil

2

C (gcc) , 388 386 302 octets

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

Essayez-le en ligne!

cleblanc
la source

1

05AB1E , 121 octets

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

Essayez-le en ligne!

Erik le Outgolfer
la source

Vous pouvez enregistrer des octets en exprimant les modèles interne et externe / interne en tant qu'entités distinctes et en utilisant replace pour les combiner de manière itérative. J'ai récemment appris cette tactique pour réduire le nombre d'octets de conversion de base lors du défi du tableau périodique :). Bubblegum le tue sur quoi que ce soit moins de 3 motifs intérieurs, et ce n'est que 1 :(. Codegolf.stackexchange.com/a/126995/59376

Magic Octopus Urn

@carusocomputing Bubblegum tue même la SOGL donc ça n'en vaut pas vraiment la peine ...

Erik the Outgolfer

1

JavaScript (ES6), 177 166 octets

_=>` 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 chaîne contient une collection de caractères à afficher ainsi que le nombre de répétitions. Si un caractère n'est pas répété, le nombre de fois peut être omis.

Les séquences de chaînes répétées sont optimisées en stockant dans les variables r et s.

Fragment:

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

Développer l'extrait

Rick Hitchcock
la source

0

Python 2 , 135 octets

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

Essayez-le en ligne!

mdahmoune
la source

0

Fusain , 52 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

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

Imprimez la moitié gauche de la mallette.

↓↷

Préparez le curseur afin que la chaîne compressée puisse être imprimée directement après réflexion. (Mettre le mouvement vers le bas après la réflexion ou avant que la chaîne compressée change leur signification.)

‖Ｏ

Réfléchissez pour terminer la mallette.

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

Imprime le montant sous forme de chaîne compressée. (Malheureusement, c'était l'approche la plus courte, car sinon, cela Mconsomme trop d'octets.)

Neil
la source

Mayweather vs McGregor: Préparez le prix en argent

introduction

Défi

But

Réponses:

Bubblegum, 55 octets

Gelée , 92 75 octets

Comment?

JavaScript (ES6), 187 184 octets

Comment?

Démo

05AB1E , 80 octets

Explication

05AB1E , 41 octets

SOGL , 58 57 octets

54 octets (en compétition? )

PHP, 117 octets

Gelée , 114 octets

Braingolf , 267 octets

/// , 155 octets

Python 2 , 221 205 197 196 193 octets

Explication:

C, 415 402 397 octets

Retina , 140 137 129 octets

C (gcc) , 388 386 302 octets

05AB1E , 121 octets

JavaScript (ES6), 177 166 octets

Python 2 , 135 octets

Fusain , 52 octets