Herausforderung

Drucken oder senden Sie das Stack Exchange-Favicon wie folgt:

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

Das ist Code-Golf , also gewinnt die kürzeste Antwort in jeder Sprache.

Operation Flashpoint- Skriptsprache, 263 195 Byte

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

Nicht das richtige Werkzeug für den Job.

Rufen Sie an mit:

hint call f;

Ausgabe:

Die Formatierung schlägt fehl, da die Schriftart keinen einheitlichen Abstand aufweist.

Charcoal , 38 37 33 30 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Bearbeiten: Es ist gelungen, ein Byte mit Hilfe einer Reflektion zu speichern, obwohl @CarlosAlejo zeigt, dass dies tatsächlich in 37 Bytes ohne Reflektion möglich ist. Sparte weitere 4 Bytes, indem du das linke ¾ zeichnest und das letzte ¼ widerspiegelst. Bearbeiten: Vorherige 33-Byte-Antwort hing ReflectButterflyOverlap()davon ab, dass der Überlappungsbereich nicht mit der Reflexion überdruckt wurde. Falls sich dieses Verhalten änderte, suchte ich nach einer Lösung, die sich nicht darauf stützte kreative Verwendung des Druckens eines Arrays. Erläuterung:

←×_χ                            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

/// 98 Bytes

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

Probieren Sie es online! Oder sehen Sie es interaktiv!

JavaScript (ES6), 113 112 Bytes

(Ein Byte dank @Craig Ayre gespeichert.)

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

SOGL V0.12 , 32 31 Bytes

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

Probieren Sie es hier aus!

Erläuterung:

...‘               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

Das Viertel:

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

und der andere Teil:

    
|  /
| /
|/

Python 2 , 115 Bytes, kreativere Idee

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

Probieren Sie es online!

Python 2 , 102 Bytes, langweilige Idee

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

Probieren Sie es online!

Python 2, 124 Bytes

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

Probieren Sie es online!

C (gcc) , 187 Bytes

2 Bytes dank Cody Gray und 3 Bytes dank 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"  |/");}

Probieren Sie es online!

Rust , 181 Bytes

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

Probieren Sie es online!

Rust , 184 Bytes

Diese Version ist möglicherweise besser zum Golfen geeignet, da das Hinzufügen weiterer replaceBytes jeweils weniger kostet. Das erste replaceist nicht Teil der Schleife, weil es das Ändern der doppelten Aufgabe sin ein Stringanstelle von ein zieht &'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}

Probieren Sie es online!

C 167 Bytes

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

Probieren Sie es online!

Hinweis: Viele sichtbare Leerzeichen oben sind eigentlich das Tabulatorzeichen.

Lesbare Version:

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

Erläuterung:

Das Datenfeld d codiert die Antwort in wörtlichen Einzelzeichen und codierten Wiederholungszeichen. Jedes Zeichen c in dem Datenfeld wird einem Basiszeichen b und einer Anzahl von Wiederholungen zugeordnet. Es wird dann so oft gedruckt.

Zeichen, die nur einzeln verwendet werden (Schrägstriche und Pipe), haben die ASCII-Codes 47, 92 und 124. Zwei davon sind durch 5 mit einem Rest von 2 teilbar (c%5=2||c>123) . Für alle drei konnte ich keine kürzere Testbedingung finden.

Wiederholte Zeichen (Unterstrich, Bindestrich und Leerzeichen) mit den ASCII-Codes 95, 45 und 32 werden mit einem höheren ASCII-Code codiert - um eins pro Wiederholung erhöht. So ist beispielsweise ein einzelnes Leerzeichen nur ein Leerzeichen, aber mit dem nächsten ASCII-Zeichen, dem Ausrufezeichen, können zwei Leerzeichen codiert werden. Wenn ein codiertes Zeichen ungeeignet wäre, weil es die oben genannte Modulo-Bedingung erfüllt, kann es wie bei # & geteilt werden, um elf Leerzeichen darzustellen. Dieselbe Technik wird verwendet, um Überlappungen zwischen Leerzeichen- und Bindestrichzeichenbereichen zu vermeiden.

Schließlich werden die zehn Zeilenumbrüche als Tabulatoren codiert, um Bytes zu sparen, die durch einen Backslash aus den Zeilenumbrüchen entfernt und zum Drucken inkrementiert worden wären ( ++c).

Kohle , 49 37 Bytes

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

Probieren Sie es online!

Endlich konnte ich ein bisschen Golf spielen. Diese Antwort verwendet (im Gegensatz zu allen anderen Ant- worten auf Holzkohle) keine Reflexion, sondern zeichnet die gesamte Kontur in einem Durchgang, wobei die horizontalen Balken am Ende verbleiben.

Link zur ausführlichen Version .

Kaugummi , 40 Bytes

1 Byte durch Entfernen einer nachgestellten Zeile gespart, danke @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...

Probieren Sie es online!

Kohle , 38 Bytes

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

Probieren Sie es online!

Ich habe Carlos 'Antwort in ihrer ursprünglichen Form als Ausgangspunkt verwendet, aber durch die Verwendung einer Reflexion unter Ausnutzung der horizontalen Symmetrie ein gutes Stück gespart. (Vertikale Symmetrie hat sich nicht gelohnt, da sich die Unterstriche in der falschen Zeile befanden.) Hier können Sie die Entwicklung der Leinwand bei jedem Schritt sehen .

Hier ist die ausführliche Version .

Python 2, 119 117 116 Bytes

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

Probieren Sie es online!

Ein bisschen gequälte Lauflängenkodierung ...

BEARBEITEN: Sparen Sie 3 Bytes, indem Sie den Satz von Längen ersetzen:

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

mit

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

C++ 11 - 162 159 154 152 150 bytes

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

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

Input string i is coded in char pairs:

1. Count of chars to repeat (added to 'a' to be a legible character)
2. Char to print

I think, there's still a lot of room for improvement here.

Edit:

1. Replaced putchar with cout<<
2. Remove while, Use string constructor to repeat chars
3. Removed space before pointer and a spurious semi-colon ;;
4. Compounding instructions with comma, removing braces.

Pyth, 74 bytes

J*21\-L*db+d*19\_++\/y19\\V2J++\|y19\|;J++++\\*T\_y4*5\_\/V3+++y11\|y-2N\/

Try it online!

R16K1S60 Assembly, 152 144 Bytes

Writes output to screen peripheral the R16K1S60 in ASCII. Runs on The Powder Toy save 2012356. (See link in header for info)

The byte size of the program is the compiled result (Cells Used * 2), not the assembly.

You know you've done well when the logo takes more space than your 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

Explanation

The assembly code above implements a simple compression algorithm, with the words 0x000C being a newline and 0x0009 being the command to stop execution.

The other words are encoded simply, like this: 0xTTCC

• T: Times to repeat the value

• C: The ASCII character to print

The ASM uses every register available to it, including some of the less commonly used ones:

• The Instruction Pointer, to get a few known values into quick recall to save some bytes (A constant value in an instuction that's not just a register uses an extra byte to store it)

• The Stack Pointer is used as 6th general purpose register, because none of the code uses the stack.

Only AX, BX, CX, and DX are actually used for important data. EX and SP are used to store some constants that get frequently used.

It's somewhat simple, and has nil chance of winning, but it was fun to write!

See revision history for the old answer (It's just as large in terms of ASM)

funfact: if this was measured in words (in the case of the R16K1S60,16 bits) it'd be smaller than the pyth answer, at 72 bytes

Jelly, 50 48 45 bytes

21“©&Ẇƥ⁸þ/Ẉoụ’ḃ1pF“CṣʠėHẹỊtṡḤḶ’ṃ“ _/\-|”¤xs¹Y

Try it online!

V, 49 bytes

i ±¹_
/±¹ \2ÙÒ-jÓÓ/|
3äkGR\±_´ µ_/
±± |  /2ñÙlx

Try it online!

Mathematica, 163 bytes

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

PHP, 86 bytes

<?=gzinflate(base64_decode("U4jHBFz6CpgghksXG+CqwaK2hgpqYxDuASkDM/S5kDUqKKDxUbn6AA"));

Try it online!

PHP, 118 bytes

<?=strtr(' 333____
/00   \
11-
|02
11-
|02
11-
\33    3/
2  /
2 /
2/',['        ','----------',"           |",_____]);

Try it online!

Python 2, 171 bytes

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

Each line is exactly 85 bytes! Hoorah!

Zsh, 244 bytes

This is specifically written for Zsh, not Bash, as it allows a bit more in terms of weird syntax.

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

Note: when I tried to run it on tio.run the output is different than on my terminal. The fix to this is replacing

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

with

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

which would make it 245 bytes (link).

Edit Seems like I was too eager to hit that post button and I missed some spaces, making my solution a bit less efficient. My new output seems off though, but I think I counted correctly (but it wouldn't change the length anyway).

Retina, 74 bytes

 _18¶/ 18\-| 18|-| 18|-\_9 3_4%  % %/
-
¶-20¶
%
/¶ 10|
\d+
$*
+`(.)1
$1$1

Try it online!

Python 2, 159 153 139 bytes

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)

Try it online!

EDIT: Saved 6 bytes by using % formatting instead of .format().
EDIT: Saved another 14 bytes by fixing the output, thanks to musicman523.

Japt, 79 72 71 bytes

" _p
/ p\\
{"-r
| p|
"²}-r
\\_g a_b/
 h|  /
 h| /
 h|/"r".%l"_g p6nZÅnH

Test it

• 7 bytes saved thanks to ETHproductions' excellent suggestion of using base 32 integers for the repetition values.

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>

Retina, 89 bytes

1"""____¶/19\¶##-¶|19|¶##-¶|19|¶##-¶\""4"/¶11|2/¶11|1/¶11|/
#
!!
"
_____
!
-----
\d+
$* 

Try it online!

Charcoal, 48 bytes

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

Try it online!

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

,,,, 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×' #