Imprimer le favicon de Stack Exchange

19

Défi

Imprimez ou renvoyez le favicon de Stack Exchange, comme indiqué ci-dessous:

 ___________________
/                   \
---------------------
|                   |
---------------------
|                   |
---------------------
\__________    _____/
           |  /
           | /
           |/

Il s'agit de code-golf , donc la réponse la plus courte dans chaque langue l'emporte.

code-golf  string  ascii-art  kolmogorov-complexity 
— musicman523
source
2
Le coin supérieur gauche est-il destiné à être légèrement désaligné?
— ETHproductions
@ETHproductions Il était prévu, mais je change maintenant. Cela a l'air un peu maladroit de toute façon.
— musicman523
2
La sortie réelle est de 219 octets, pour référence.
— 2017 totalement humain à 1h55
Les lignes de fin et / ou les espaces de fin sur les lignes sont autorisés, non?
— dzaima
1
— Taylor Scott

Réponses:

43

Langage de script Operation Flashpoint , 263 195 octets

f={r="                   ";t="---------------------\n";s=" ___________________\n/"+r+"\\n"+t+"|"+r+"|\n"+t+"|"+r+"|\n"+t+"\__________    _____/\n           |  /\n           | /\n           |/";s}

Pas le bon outil pour le travail.

Appeler avec:

hint call f;

Production:

Le formatage échoue, car la police n'est pas à espacement fixe.

— Steadybox
source
49
Juste ce qui vous fait regarder un défi et penser "oh, je devrais répondre à l'opération Flashpoint" me
— laisse
7
@totallyhuman Je suppose que son langage de script est tout simplement amusant à écrire. Il a quelques bizarreries et limitations, donc vous devez parfois utiliser d'étranges solutions de contournement, ce qui le rend intéressant (mais pas très pratique).
— Steadybox
5
Le codage en dur de la réponse vous donnerait probablement un meilleur score.
— NieDzejkob
2
@NieDzejkob Maintenant, c'est plus court que de coder en dur la sortie, mais plus ennuyeux que la version précédente.
— Steadybox
@totallyhuman Et avec ce défi en particulier, je voulais tester comment la langue s'en sortirait avec un défi de complexité de Kolmogorov (pour lequel il est loin d'être idéal pour).
— Steadybox du
11

Fusain , 38 37 33 30 octets

←×_χ↓Ｆ/||⟦ι¹¹⟧\×_⁹‖Ｂ_×ψ⁴↙↙³↑↑³

Essayez-le en ligne! Le lien est vers la version détaillée du code. Edit: Géré pour enregistrer un octet à l'aide d'une réflexion, bien que @CarlosAlejo montre qu'il peut en fait être fait en 37 octets sans réflexion. 4 octets supplémentaires enregistrés en dessinant le the gauche et en reflétant le ¼ final. Edit: la réponse précédente de 33 octets dépendait de ReflectButterflyOverlap()ne pas surimprimer la zone de chevauchement avec la réflexion, donc au cas où ce comportement changerait, j'ai cherché une solution qui ne reposait pas sur cela, et le résultat s'est avéré être de toute façon plus court, grâce à mon utilisation créative de l'impression d'un tableau. Explication:

←×_χ                            Print 10 `_`s leftwards (top row)
    ↓                           Move down to the next row
     Ｆ/||                       For each character in the string `/||`
          ι                     Current character
           ¹¹                   Integer 11, prints as `-----------`
         ⟦   ⟧                  Put both into an array
                                Implicitly print on separate lines
              \                 Implicitly print `\`
               ×_⁹              Implicitly print 9 `_`s
                  ‖Ｂ            Reflect right, overlapping the axis
                    _           Implicitly print `_`
                     ×ψ⁴        Implicitly delete 4 characters
                        ↙↙³     Move down left and print three `/`s
                           ↑↑³  Move up and print three '|'s
— Neil
source
2
Très bien joué. J'adore qu'il y ait quatre réponses au fusain à cette question! ‖ＢＯn'était pas dans la langue la dernière fois que je l'ai utilisé - je devrai garder cela à l'esprit pour l'avenir.
— DLosc
J'ai dû voir par moi-même ce que vous vouliez dire par "refléter le ¼ final". Bien joué en effet!
— Charlie
8

/// , 98 octets

/'/  //&/
"""
|!! |//%/\\\/
!'|//#/_____//"/-------//!/'''' / ###____
\/!! \\&&
"""
\\##''#%'% %\/

Essayez-le en ligne! Ou voyez-le de manière interactive!

— Conor O'Brien
source
3
Existe-t-il un utilitaire qui me permet de voir les différentes "étapes" d'un programme ///? (Exécution partielle après chaque remplacement.) Cela pourrait m'aider à mieux les comprendre.
— CAD97
@ CAD97 J'ai bidouillé avec l'interpréteur en ligne, et il venait généralement avec des options de débogage, mais la façon dont l'interprète en ligne ordonne les arguments, il ne fonctionne pas de cette façon. Vous pouvez saisir une copie de l'interprète vous-même et faire quelque chose comme perl slashes.pl -d1 code.txt. Je travaille actuellement sur un environnement d'exécution en ligne pour ///, mais cela peut prendre un certain temps.
— Conor O'Brien
3
@ CAD97 Said chose en ligne est en place, jetez un oeil!
— Conor O'Brien
8

JavaScript (ES6), 113 112 octets

(Enregistré un octet grâce à @Craig Ayre.)

let f=

_=>` _19
/ 19\\
-21
| 19|
-21
| 19|
-21
\\_10 4_5/
 11| 2/
 11| /
 11|/`.replace(/.(\d+)/g,([a],b)=>a.repeat(b))
 
 console.log(f());
Développer l'extrait

— Rick Hitchcock
source
Il semble que vous ayez un espace libre avant la fonction de remplacement. Je venais de proposer une mise à jour similaire pour ma solution JS à 113 octets. Je ne sais pas si je devrais l'afficher ou vous le laisser.
— Shaggy
Ah, attendez, ne voyant que maintenant que vous avez posté votre solution avant de poster la mienne. Je supprimerai le mien lorsque j'arriverai sur un ordinateur et vous pourrez enregistrer un octet avec replace(/.(\d+)/g,(a,b)=>a[0].repeat(b)).
— Shaggy
Merci, Shaggy. J'avais écrit un programme pour automatiser ce type de réponse, et c'était idiot de le faire sortir un espace inutile. Votre proposition replaceest certainement une amélioration, que j'ai maintenant incorporée à mon programme.
— Rick Hitchcock
1
Pouvez - vous enregistrer un tableau d' octets correspondant a: ([a],b)=>a.repeat(b))?
— Craig Ayre
Oui merci! Je ne connaissais pas cette syntaxe.
— Rick Hitchcock
7

SOGL V0.12 , 32 31 octets

^$∙r↑Ψ«2τγæΕž‘╬Æ╬⁷"ƧΡ⅟?0Ξ³‘6«8ž

Essayez-le ici!

Explication:

...‘               push a quarter of the icon
    Β             palindromize vertically
      ╬⁷           palindromize horizontally (these two should be ╬3 together, but spacing doesn't work correctly (though now it does since I fixed it))
        "...‘      push the extention
             6«8ž  at coordinates [12; 8] in the quad-palindromized image put that in

Le quartier:

 __________
/
-----------
|
-----------

et l'autre partie:

    
|  /
| /
|/
— dzaima
source
"ensemble"? "creux"? De plus, il a fallu un peu de temps pour comprendre ce que .voulait dire l'explication string. Peut-être utiliser ^...'et "...'?
— CalculatorFeline
@CalculatorFeline Je faisais d'habitude ...pour les chaînes compressées (alias non-sens) mais dernièrement, j'ai commencé à en faire une ou deux. Et n'hésitez pas à corriger mes erreurs et ma grammaire: p
— dzaima
7

Python 2 , 115 octets, idée plus créative

t,u,v,w,x,y,z='\n -/\\_|';k=w+t+11*u+z;i=t+21*v+t
print u+19*y+t+w+19*u+x+(i+z+19*u+z)*2+i+x+10*y+4*u+5*y+k+u,k,k+w

Essayez-le en ligne!

Python 2 , 102 octets, idée ennuyeuse

print'eNrjUojHBFz6CpgghksXG+CqwaK2hgpqYxDuASkDM/S5kDUqKKDxUbn6XADUmClx'.decode('base64').decode('zip')

Essayez-le en ligne!

— mdahmoune
source
2
Je suis en train de voter contre cela car j'ai vu cette méthode trop souvent utilisée. C'est juste ennuyeux de voir encore et encore.
— R. Kap
8
@ R.Kap Sauf s'il y a un chemin plus court, c'est une raison plutôt arbitraire de downvote.
— Dennis
1
@Dennis Peut-être, mais je reste fidèle à mon opinion et j'ai le droit de l'exprimer. J'ai vu cette méthode utilisée un nombre incalculable de fois sur ces types de défis et elle nécessite peu ou pas de créativité de la part du PO, qui sont de grands aspects, du moins à mon avis, des défis de complexité de Kolomogorov, et donc ma raison pour le vote négatif. .
— R. Kap
2
@ R.Kap Si les algorithmes de compression à usage général peuvent facilement battre les manuels, c'est un problème de défi, pas la réponse. Je n'ai même pas réussi à battre Bubblegum avec Jelly, et la décompression avait très peu de frais généraux dans Jelly.
— Dennis
2
@Dennis Je ne parle même pas de la longueur du code ici. Je parle d'effort et de créativité, que cette réponse, à mon avis, ne parvient pas à mettre en valeur dans une langue où l'on peut faire beaucoup plus, c'est la raison pour laquelle j'ai voté contre. Maintenant, si vous n'êtes pas d'accord avec mon raisonnement, ça va. Dans ce cas, acceptons simplement d'être en désaccord et de terminer cette conversation ici avant qu'elle ne soit trop longue. :)
— R. Kap
6

Python 2, 124 octets

a,b,d,e,f,g,h=' _-|/\\\n';r=d*21+h+e+a*19+e+h;n=f+h+a*11+e;print a+b*19+h+f+a*19+g+h+r*2+r[:22]+g+b*10+a*4+b*5+n+a*2+n+a+n+f

Essayez-le en ligne!

— R. Kap
source
Vous ne l'utilisez jamais c, vous pouvez donc l'éliminer sur 3 octets. Essayez-le en ligne!
— musicman523
@ musicman523 Je ne sais même pas pourquoi je mets ça là. Merci pour la capture! :)
— R. Kap
6

C (gcc) , 187 octets

Enregistré 2 octets grâce à Cody Gray et 3 octets grâce à Keyu Gan!

#define a"         "
#define s a" "a
#define l"\n---------------------\n"
f(){puts(" ___________________\n/"s"\\"l"|"s"|"l"|"s"|"l"\\__________    _____/\n"a"  |  /\n"a"  | /\n"a"  |/");}

Essayez-le en ligne!

— musicman523
source
2
putsserait trivialement plus court, si une nouvelle ligne de fin est acceptable.
— Cody Gray
vous pouvez utiliser à la f()place de main(). Une fonction est également acceptable.
— Keyu Gan
5

Rouille , 181 octets

||" ___________________
/2\\
1
1
3
\\__________    _____/
4|  /
4| /
4|/".replace("1","3
|2|").replace("2",&" ".repeat(19)).replace("3",&"-".repeat(21)).replace("4",&" ".repeat(11))

Essayez-le en ligne!

Rouille , 184 octets

Cette version peut être plus jouable car l'ajout de replacecoûts supplémentaires coûte moins d'octets chacun. Le premier replacene fait pas partie de la boucle car il transforme le double devoir sen un Stringau lieu d'un &'static str.

||{let mut s=" 5__5__5
/2\\
1
1
3
\\55    5/
4|  /
4| /
4|/".replace("1","3
|2|");for p in vec![("2"," ",19),("3","-",21),("4"," ",11),("5","_",5)]{s=s.replace(p.0,&p.1.repeat(p.2))}s}

Essayez-le en ligne!

— CAD97
source
5

C, 167 octets

i;char*d=" q    /()\\   A   |()|    A   |()|    A   \\h#c/  #&|!/   #&| /   #&|/",c,b;main(j){while(c=d[i++],b=c%5==2||c>123?c:c>95?95:c>45?45:c>=32?32:++c,i<47)for(j=c;j-->=b;)putchar(b);}

Essayez-le en ligne!

Remarque: beaucoup d'espaces apparents ci-dessus sont en fait le caractère de tabulation.

Version lisible:

i;
char *d = " q   /()\\   A   |()|    A   |()|    A   \\h#c/  #&|!/   #&| /   #&|/", c, b;
main(j) {
    while(
        c = d[i++],
        b = c % 5==2 || c > 123 ? c:
            c > 95 ? 95:
            c > 45 ? 45:
            c >= 32 ? 32:
            ++c,
        i < 47
    )
        for(j = c; j-- >= b;)
            putchar(b);
}

Explication:

Le tableau de données, d, code la réponse en caractères simples littéraux et en caractères répétés codés. Chaque caractère, c, dans le tableau de données est mappé sur un caractère de base, b, et un certain nombre de répétitions. Il est ensuite imprimé à plusieurs reprises.

Les caractères qui sont utilisés seuls (barres obliques et pipe) ont les codes ASCII 47, 92 et 124. Deux d'entre eux sont divisibles par 5 avec un reste de 2 (c%5=2||c>123). Je n'ai pas pu trouver une condition plus courte pour tester pour les trois.

Les caractères qui sont répétés (trait de soulignement, tiret et espace), avec les codes ASCII 95, 45 et 32 ​​respectivement, sont codés avec un code ASCII supérieur - augmenté d'une unité par répétition. Ainsi, par exemple, un seul espace n'est qu'un espace, mais deux espaces peuvent être codés par le caractère ASCII suivant, le point d'exclamation. Lorsqu'un caractère codé ne conviendrait pas car il remplit la condition modulo ci-dessus, il peut être divisé, comme avec # & pour représenter onze espaces. La même technique est utilisée pour éviter le chevauchement entre les plages de caractères espace et tiret.

Enfin, les dix sauts de ligne sont encodés sous forme d'onglets pour enregistrer les octets qui auraient été dépensés pour échapper aux sauts de ligne avec une barre oblique inverse, puis incrémentés pour print ( ++c).

— jiv
source
Bien joué! Je savais qu'il y avait de meilleures réponses C là-bas.
— musicman523
Merci! C'était un défi amusant. J'ai passé quelque chose comme quatre heures dessus, donc je suis content que ça ait fini par marcher.
— jiv
4

Fusain , 49 37 octets

↓⁵\…_χ↓↓³↗↗³…_⁵↑/↑⁵↖\←…_¹⁹↓ /Ｆ³«Ｐ²¹¶¶

Essayez-le en ligne!

Enfin, j'ai pu jouer un peu au golf. Cette réponse (contrairement à toutes les autres réponses au fusain) n'utilise pas de réflexion, mais dessine tout le contour en un seul passage, laissant les barres horizontales pour la fin.

Lien vers la version détaillée .

— Charlie
source
"Contrairement à toutes les autres réponses au fusain" En fait, ma première réponse n'a pas utilisé de réflexion non plus, mais je dois admettre que je n'ai pas vu la chance de jouer un octet au golf en commençant le dessin avec la ligne verticale gauche. (Les seuls autres changements entre nos solutions sont que vous utilisez Range où j'ai utilisé Times et que vous imprimez un \où je viens d'imprimer :UpLeft1 étape.)
— Neil
Bien qu'il semble que le reflet soit en route ...
— Neil
C'est aussi deux fois maintenant que ma clé n'a pas fonctionné ...
— Neil
3

Bubblegum , 40 octets

1 octet enregistré en supprimant une nouvelle ligne de fin, merci @ovs!

00000000: 5388 c704 5cfa 0a98 2086 4b17 1be0 aac1  S...\... .K.....
00000010: a2b6 860a 6a63 10ee 0129 0333 f4b9 9035  ....jc...).3...5
00000020: 2a28 a0f1 51b9 fa00                      *(..Q...

Essayez-le en ligne!

— musicman523
source
Sans une nouvelle ligne de fin, cela obtient 40 octets .
— ovs
Merci! Je pense que mon éditeur de texte en a automatiquement mis un.
— musicman523
Comment avez-vous créé cela? zlib.compress(s.encode(), 9)renvoie 46 octets, et la réponse semble être zlib.
— NieDzejkob
Par la suggestion de Dennis , j'ai utilisé zopfli --deflatepour générer le flux DEFLATE brut, puis utilisé xxdpour le convertir au format xxd. Je crois qu'il zliblaisse une somme de contrôle, ou n'est pas un flux DEFLATE brut pour une autre raison.
— musicman523
3

Fusain , 38 octets

←…_χＰ↑⁵Ｐ\Ｆ³«↑Ｐ¹¹↑»↗¹…_χ‖ＢＭ²¦⁷Ｐ↓⁴… ⁴↙↙³

Essayez-le en ligne!

J'ai utilisé la réponse de Carlos dans sa forme originale comme point de départ, mais j'ai économisé un peu en utilisant une réflexion, en profitant de la symétrie horizontale. (La symétrie verticale n'en valait pas la peine car les traits de soulignement se sont retrouvés sur la mauvaise ligne.) Vous pouvez voir l'évolution de la toile à chaque étape ici .

Voici la version détaillée .

— DLosc
source
btw vous pouvez utiliser -dpour montrer chaque étape (aussi désolé d'avoir tellement changé le charbon de bois, je ne suis pas sûr que beaucoup de nouvelles idées soient très utiles, en particulier le chèvre ascii-art intégré et une partie de la langue wolfram haha)
— ASCII uniquement le
1
— ASCII uniquement
3

Python 2, 119 117 117 116 octets

print''.join(' \n-/|\\_'[ord(x)/8-4]*int('1245abjl'[ord(x)%8],36)for x in' V(8&H(7(@&@(7(@&@(7(HT"S8(%@!8(%@ 8(%@8')

Essayez-le en ligne!

Un peu d'encodage torturé sur toute la durée ...

EDIT: économisez 3 octets en remplaçant l'ensemble de longueurs:

[1,2,4,5,10,11,19,21][ord(x)%8]

avec

int('1245abjl'[ord(x)%8],36)

— Chas Brown
source
Hou la la! J'essayais de penser à un moyen efficace de le faire moi-même.
— GarethPW
Beau code, mais il semble que ce soit 119 octets?
— mdahmoune
@mdahmoune: Tout à fait raison - j'ai oublié d'utiliser r''lors de la vérification de la longueur ...
— Chas Brown
3

C ++ 11 - 162 159 154 152 150 octets

MSVC:

void f(){char*i="b t_b\nb/t b\\b\nv-b\nb|t b|b\nv-b\nb|t b|b\nv-b\nb\\k_e f_b/b\nl b|c b/b\nl b|b b/b\nl b|b/";while(*i)cout<<string(*i++-97,*i),i++;}

GCC: (+4 caractères)

int f(){char*i="b t_b\nb/t b\\b\nv-b\nb|t b|b\nv-b\nb|t b|b\nv-b\nb\\k_e f_b/b\nl b|c b/b\nl b|b b/b\nl b|b/";while(*i){cout<<string(*i-97,*(i+1));i+=2;}}

Chaîne d'entrée i est codée en paires de caractères:

  1. Nombre de caractères à répéter (ajouté à 'a' pour être un caractère lisible)
  2. Caractère à imprimer

Je pense qu'il y a encore beaucoup de place à l'amélioration ici.

Éditer:

  1. Putchar remplacé par cout <<
  2. Supprimer tout, utiliser le constructeur de chaîne pour répéter les caractères
  3. Suppression de l'espace avant le pointeur et un point-virgule parasite ;;
  4. Instructions de composition avec virgule, suppression des accolades.
— Robert Andrzejuk
source
C ++ 11 ne prend pas en charge autocomme type de retour, c'est une fonctionnalité C ++ 14. Cependant, vous pouvez résoudre ce problème et enregistrer un octet en définissant le type de retour int. Il ne semble pas que ce code fonctionne, cependant; pourriez-vous le tester sur Essayez-le en ligne! et voyez si vous pouvez le réparer?
— musicman523
Modification du type de retour auto -> void. Je testais sur Visual Studio 2017 - automatiquement C ++ 14. Ajout d'une version pour gcc.
— Robert Andrzejuk
Oh d'accord, gotcha. J'utilise Linux donc je n'ai pas VS. Bon travail!
— musicman523
Salut Robert - votre approche d'encodage de longueur de course est similaire à la mienne; voir ici . En outre, j'emballe chaque paire (longueur, caractère) dans un seul caractère au lieu de 2. Il y a 7 caractères possibles et 8 longueurs distinctes; donc j'utilise les 56 caractères ' '..'X'pour l'encodage; ce qui économise 40 octets avec un peu de surcharge supplémentaire pour le décodage.
— Chas Brown
3

Assemblée R16K1S60 , 152 144 Octets

Écrit la sortie pour filtrer le périphérique du R16K1S60 en ASCII. Fonctionne sur le jouet Powder save 2012356. (Voir le lien dans l'en-tête pour plus d'informations)

La taille en octets du programme est le résultat compilé (cellules utilisées * 2), pas l'assembly.

Vous savez que vous avez bien fait lorsque le logo prend plus de place que votre bytecode.

a:
mov ex, ip
mov ax, .string
mov sp, ip
mov dx, 0x1000
send sp, dx
.loop:
mov bx, [ax]
cmp bx, ip
je .end
cmp bx, ip
je .newline

shr bx, cx, 8
and cx, 0x00FF
.inner:
send sp, cx
sub bx, ex
jnz .inner
.reentry:
add ax, ex
jmp .loop
.newline:
add dx, 0x0020
send sp, dx
jmp .reentry
.string:
dw 0x0120
dw 0x135F
dw 0x000C
dw 0x012F
dw 0x1320
dw 0x015C
dw 0x000C
dw 0x152D
dw 0x000C
dw 0x017C
dw 0x1320
dw 0x017C
dw 0x000C
dw 0x152D
dw 0x000C
dw 0x017C
dw 0x1320
dw 0x017C
dw 0x000C
dw 0x152D
dw 0x000C
dw 0x015C
dw 0x0A5F
dw 0x0420
dw 0x055F
dw 0x012F
dw 0x000C
dw 0x0B20
dw 0x017C
dw 0x0220
dw 0x012F
dw 0x000C
dw 0x0B20
dw 0x017C
dw 0x0120
dw 0x012F
dw 0x000C
dw 0x0B20
dw 0x017C
dw 0x012F
dw 0x0009
.end:
hlt

Explication

Le code d'assembly ci-dessus implémente un algorithme de compression simple, avec les mots 0x000C étant une nouvelle ligne et 0x0009 étant la commande pour arrêter l'exécution.

Les autres mots sont encodés simplement, comme ceci: 0xTTCC

  • T: Temps de répétition de la valeur

  • C: Le caractère ASCII à imprimer

L'ASM utilise tous les registres à sa disposition, y compris certains des moins couramment utilisés:

  • Le pointeur d'instructions, pour obtenir un rappel rapide de quelques valeurs connues pour enregistrer quelques octets (une valeur constante dans une instuction qui n'est pas seulement un registre utilise un octet supplémentaire pour le stocker)

  • Le Stack Pointer est utilisé comme 6ème registre à usage général, car aucun code n'utilise la pile.

Seuls AX, BX, CX et DX sont réellement utilisés pour les données importantes. EX et SP sont utilisés pour stocker certaines constantes qui sont fréquemment utilisées.

C'est un peu simple et n'a aucune chance de gagner, mais c'était amusant d'écrire!

Voir l'historique des révisions pour l'ancienne réponse (elle est tout aussi importante en termes d'ASM)

funfact: si cela était mesuré en mots (dans le cas des bits R16K1S60,16), il serait plus petit que la réponse pyth, à 72 octets

— moonheart08
source
2

Mathematica, 163 octets

Row@Map[Column,Characters/@{" /-|-|-\\   ",r="_ - - -_   ",r,r,r,r,r,r,r,r,r,"_ - - - |||","_ - - -   /","_ - - -  / ","_ - - - /  ",r,r,r,r,r," \\-|-|-/   "},{1}]
— J42161217
source
2

Python 2, 171 octets

p,u,q,v,r,s,F=' ','_','/','|','-'*21,'\\',lambda f,m:f+m*19+f;B=lambda n:p*11+v+p*n+q
print'\n'.join([F(p,u),q+p*19+s,r,F(v,p),r,F(v,p),r,s+u*10+p*4+u*5+q,B(2),B(1),B(0)])

Chaque ligne fait exactement 85 octets! Hoorah!

— Daniel
source
2

Zsh, 244 octets

Ceci est spécifiquement écrit pour Zsh, pas Bash, car il permet un peu plus de syntaxe bizarre.

alias p=printf
function r { p "$1%.s" {0..$2}}
function l { p $1;r $2 19;p $3;p "\n"}
l " " _ " "
l / " " \\
l - - -
l \| " " \|
l - - -
l \| " " \|
l - - -
p \\
r _ 10
r " " 4
r _ 5
p "/\n"
r " " 11
p "|  /\n"
r " " 11
p "| /\n"
r " " 11
p \|/

Remarque: lorsque j'ai essayé de l'exécuter sur tio.run, la sortie est différente de celle de mon terminal. La solution est de remplacer

function r { p "$1%.s" {0..$2}}

avec

function r { p "$1%.0s" {0..$2}}

ce qui en ferait 245 octets ( lien ).

Modifier On dirait que j'étais trop impatient de cliquer sur ce bouton de publication et que j'ai manqué quelques espaces, ce qui rend ma solution un peu moins efficace. Ma nouvelle sortie semble éteinte cependant, mais je pense que j'ai compté correctement (mais cela ne changerait pas la longueur de toute façon).

— Luca_Scorpion
source
Bienvenue chez PPCG! Notez que la ligne inférieure des traits de soulignement comporte un espace de quatre espaces, ce qui manque dans la sortie de votre code.
— Steadybox
@Steadybox Ohh idiot moi. J'ai mis à jour la réponse, merci de l'avoir signalé!
— Luca_Scorpion
Aucun problème! Malheureusement, je pense que c'est encore un peu décalé, mais cela devrait le réparer (et cela vous fait économiser un octet aussi!).
— Steadybox
Je pense que vous pouvez économiser quelques octets en utilisant 'funcname () {}' au lieu de 'function funcname {}'
— Winny
2

Python 2, 159 153 139 octets

s=" "*19;e="-"*21;a=" "*9;print" %s\n/%s\\\n%s\n|%s|\n%s\n|%s|\n%s\n\%s    %s/\n%s|  /\n%s| /\n%s|/"%("_"*19,s,e,s,e,s,e,"_"*8,"_"*7,a,a,a)

Essayez-le en ligne!

EDIT: enregistré 6 octets en utilisant la %mise en forme au lieu de .format().
EDIT: enregistré 14 octets supplémentaires en corrigeant la sortie, grâce à musicman523.

— LyricLy
source
1
This isn't printing the exact text (extra lines are present). Fixing this will probably save some bytes as well.
— officialaimm
Here is a fixed version, coming in at a hot 139 bytes
— musicman523
1

JavaScript (ES6), 151 bytes

_=>` 2_________
/0\\
1
|0|
1
|0|
1
\\2    _____/
3|  /
3| /
3|/`.replace(/\d/g,a=>a.repeat.call(...[[" ",19],["-",21],["_",10],[" ",11]][a]))

Test Snippet

f=
_=>` 2_________
/0\\
1
|0|
1
|0|
1
\\2    _____/
3|  /
3| /
3|/`.replace(/\d/g,a=>a.repeat.call(...[[" ",19],["-",21],["_",10],[" ",11]][a]))

O.innerHTML=f()
<pre id=O>
Expand snippet

— Justin Mariner
source
1

Charcoal, 48 bytes

↙¹→Ｐ¹¹↓↓¹Ｐ¹¹‖Ｂ↓¦↘→×¹⁰_Ｍ⁷↑←←×¹⁰_‖ＢＪ¹¹¦⁶→×⁴ ↙↙³↑↑³

Try it online!

Somewhat different internals than Carlos's, although not visible at first.

— Erik the Outgolfer
source
1

,,,, 115 101 98 bytes

I am absolutely ashamed that this is the best I can produce. >.>

"|/
"' 11×:"| /
"⇆:"|  /
"⇆'
'/'_5×' 4×'_10×92c'
'|' 19×'|'
'-21×+++++3×110⇆⊣"\
"' 19×'/'
'_19×' #
— totallyhuman
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.