도전

아래와 같이 스택 교환 파비콘을 인쇄하거나 반환하십시오.

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

이것은 code-golf 이므로 각 언어에서 가장 짧은 답변이 이깁니다.

인화점 스크립팅 언어, 263195 바이트

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

작업에 적합한 도구가 아닙니다.

전화 :

hint call f;

산출:

글꼴이 고정 폭이 아니기 때문에 서식이 설정되지 않습니다.

숯 , 38 37 33 30 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 편집 : @CarlosAlejo가 반영하지 않고 37 바이트로 실제로 수행 할 수 있음을 보여 주지만 반사를 사용하여 바이트를 저장하도록 관리했습니다. 왼쪽 ¾을 그리고 마지막 ¼을 반영하여 4 바이트를 더 절약했습니다. 편집 : 이전 33 바이트 대답은 ReflectButterflyOverlap()리플렉션으로 겹침 영역을 중복 인쇄하지 않는 것에 달려 있었 으므로이 동작이 변경되면 그에 의존하지 않는 솔루션을 찾았으며 결과는 어쨌든 더 짧았습니다. 어레이 인쇄를 창의적으로 사용합니다. 설명:

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

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

온라인으로 사용해보십시오! 또는 대화식으로보십시오!

자바 스크립트 (ES6), (113) 112 바이트

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

SOGL V0.12 , 32 31 바이트

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

여기 사용해보십시오!

설명:

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

분기 :

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

그리고 다른 부분 :

    
|  /
| /
|/

Python 2 , 115 바이트, 더 창의적인 아이디어

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

온라인으로 사용해보십시오!

파이썬 2 , 102 바이트, 지루한 아이디어

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

온라인으로 사용해보십시오!

파이썬 2, 124 바이트

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

온라인으로 사용해보십시오!

C (gcc) 187 바이트

Cody Gray 덕분에 2 바이트를 절약하고 Keyu Gan 덕분에 3 바이트를 절약했습니다!

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

온라인으로 사용해보십시오!

녹 , 181 바이트

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

온라인으로 사용해보십시오!

녹 , 184 바이트

이 버전은 더 replace적은 바이트를 더 추가하여 더 골프화 할 수 있습니다 . 첫 번째 replace는 이중 의무 변경 s을 a String대신 으로 가져 오기 때문에 루프의 일부가 아닙니다 &'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}

온라인으로 사용해보십시오!

C, 167 바이트

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

온라인으로 사용해보십시오!

참고 : 위의 많은 공백은 실제로 탭 문자입니다.

읽을 수있는 버전 :

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

설명:

데이터 배열 d는 답을 리터럴 단일 문자와 코드화 된 반복 문자로 인코딩합니다. 데이터 배열의 각 문자 c는 기본 문자 b와 여러 반복에 매핑됩니다. 그런 다음 여러 번 인쇄됩니다.

단독으로 사용되는 문자 (슬래시 및 파이프)에는 ASCII 코드 47, 92 및 124가 있습니다.이 중 2는 5로 나눌 수 있으며 나머지는 2 (c%5=2||c>123)입니다. 세 가지 모두를 테스트하는 더 짧은 조건을 찾을 수 없습니다.

ASCII 코드 95, 45 및 32로 각각 반복되는 문자 (밑줄, 대시 및 공백)는 반복 당 하나씩 증가하는 더 높은 ASCII 코드로 코딩됩니다. 예를 들어, 단일 공백은 단지 공백이지만 다음 ASCII 문자 인 느낌표로 두 공백을 코딩 할 수 있습니다. 코딩 된 문자가 위의 모듈러스 조건을 충족하기 때문에 적합하지 않은 경우, # &와 같이 11 개의 공백을 나타 내기 위해 분할 될 수 있습니다. 공백과 대시 문자 범위 사이의 겹침을 피하기 위해 동일한 기술이 사용됩니다.

마지막으로 10 개의 줄 바꿈은 백 슬래시로 줄 바꿈을 이스케이프 처리하는 데 사용 된 바이트를 저장하기 위해 탭으로 인코딩 된 다음 인쇄를 위해 증가합니다 ( ++c).

숯 , 49 37 바이트

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

온라인으로 사용해보십시오!

마침내 나는 이것을 조금 골프화 할 수 있었다. 이 답변은 다른 모든 차콜 답변과 달리 반사를 사용하지 않지만 한 번에 모든 윤곽선을 그려서 수평 막대를 남겨 둡니다.

자세한 버전으로 연결합니다 .

풍선 껌 , 40 바이트

@ovs 덕분에 후행 줄 바꿈을 제거하여 1 바이트를 절약했습니다!

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

온라인으로 사용해보십시오!

숯 , 38 바이트

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

온라인으로 사용해보십시오!

나는 Carlos의 답을 원래 형태 로 점프 포인트로 사용했지만 수평 대칭을 이용하여 반사를 사용하여 좋은 결과를 얻었습니다. (밑줄이 잘못된 행에 있었기 때문에 수직 대칭은 그만한 가치가 없었습니다.) 여기서 각 단계 에서 캔버스의 진화를 볼 수 있습니다 .

자세한 버전 은 다음과 같습니다 .

파이썬 2 119 117 116 바이트

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

온라인으로 사용해보십시오!

약간의 고문 된 런 렝스 인코딩 ...

편집 : 길이 세트를 바꾸어 3 바이트를 절약하십시오.

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

와

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

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

입력 문자열 i은 문자 쌍으로 코딩됩니다.

1. 반복 할 문자 수 ( 'a'에 추가되어 읽을 수있는 문자 임)
2. 인쇄 할 문자

여기에는 여전히 개선의 여지가 많다고 생각합니다.

편집하다:

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