이 정확한 텍스트를 인쇄하거나 출력하는 프로그램 또는 함수를 작성하십시오 (142 자로 구성됨).

()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|

프로그램은 입력 할 필요가 없으며 (예 :와 같은 불가능한 언어는 제외 sed) 위의 텍스트 (및 위의 텍스트 만 )를 출력으로 생성해야합니다. 후행 줄 바꿈이 허용됩니다.

이것은 code-golf 이므로 가장 짧은 답변 (바이트)이 이깁니다.

MATL , 70 68 67 바이트

'()'12:)l10:&<toYP43Y$51hb(!10Xy'\::\'FFhZ++'|'3$Yc'||\'3:(95'Zd'o(

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

설명

엉망이야 그러나 야, 컨볼 루션이있다!

주어진 문장 이후에 스택 내용을 검사 할 수 있다면 설명이 더 명확해질 것 입니다. 그렇게하려면 X#0$%해당 시점에 삽입하십시오 . (이것은 X# 스택 내용을 보여주고, 0$암시 적으로 다른 것을 표시하지 말고 %나머지 코드를 주석 처리하십시오.) 예를 들어 컨벌루션 바로 뒤의 스택을 참조하십시오 .

'()'       % Push this string
12:        % Range [1 2 ... 12]
)          % Index into string (modular, 1-based): gives '()()()()()()'
l          % Push 1 (will be used later)
10:        % Range [1 2 ... 10]
&<         % All pairwise "less than" comparisons. Gives matrix with "true"
           % below the main diagonal, and the remining entries equal to "false"
to         % Duplicate. Convert to numbers (true becomes 1, false becomes 0)
YP43Y$     % Compute pi with 43 significant digits (42 decimals). Gives a string
51h        % Append last decimal, '3' (ASCII 51). This is needed to avoid rounding
b          % Bubble up the true-false matrix, to be used as logical index
(          % Fill the chars from the pi string into the 0-1 matrix, at the positions
           % indicated by the true-false matrix. Thus each 1 is replaced by a char
           % from the pi string. Entries that were 0 remain as 0. This is done in
           % columm-major order...
!          % ...so transpose to make it row-major
10Xy       % Identity matrix of size 10
'\::\'     % Push this string...
FFh        % ...and append two zeros
Z+         % 2D convolution keeping size. The identity matrix convolved with the
           % above string gives the diagonal bands with chars '\'  and ':'
+          % Add to the matrix containing the digits of pi. At each entry, only one
           % of the two matrices is nonzero
'|'        % Push this string
3$Yc       % Three-input string concatenation. This prepends the 1 (which was pushed
           % a while ago) and appends '|' to each row of the matrix. This converts
           % the matrix to char. Note that char 1 will be displayed as a space. We
           % used char 1 and not char 0 (which would be displayed as a space too)
           % because function `Yc` (`strcat`) strips  off trailing space from the
           % inputs, counting char 0 as space, but not char 1
'||\'      % Push this string
3:(        % Assign it to the first 3 entries of the matrix (column-major), that is, 
           % to the top of the first column
95         % Push ASCII for '_'
'Zd'o      % Push string 'Zd' and convert to numbers: gives [90 100]. These are the
           % (column-major) indices where the '_' char should appear in the last row
(          % Fill those chars
           % Implicitly display. (Chars 0 and 1 are displayed as space)

펄, 93 바이트

$_=bpi$=;printf'()'x6x!$`.'
%12s',F.ee x!$\--^substr"\32::\\$&|",-12while/.{$\}/g

-l71Mbignum=bpi14로 계산 된 명령 행 옵션이 필요합니다 \32. 문자 리터럴 26으로 대체해야합니다.

샘플 사용법

$ perl -l71Mbignum=bpi pi-slice.pl
()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|

펄, 111 바이트

$_=bpi$_*($l=($.=$_)-3);printf'()'x($./2)x!$`."
%$.s",F.ee x!$l--^substr"\32::\\$&|",-$.while/.{$l}/g

매개 변수화 된 버전. -nMbignum=bpi12로 계산 된 명령 행 옵션이 필요합니다 .

샘플 사용법

$ echo 10 | perl -nMbignum=bpi pi-slice.pl
()()()()()
|\3.14159|
|:\265358|
\::\97932|
 \::\3846|
  \::\264|
   \::\33|
    \::\8|
     \__\|

$ echo 20 | perl -nMbignum=bpi pi-slice.pl
()()()()()()()()()()
|\3.141592653589793|
|:\2384626433832795|
\::\028841971693993|
 \::\75105820974944|
  \::\5923078164062|
   \::\862089986280|
    \::\34825342117|
     \::\0679821480|
      \::\865132823|
       \::\06647093|
        \::\8446095|
         \::\505822|
          \::\31725|
           \::\3594|
            \::\081|
             \::\28|
              \::\4|
               \__\|

자바 스크립트 (ES6) 187 174 바이트

이는 1 바이트 짧은 단지 일반 텍스트를 표시하는 것보다.

for(y=n=0,s=`()()()()()()
`;y<10;y++,s+=`|
`)for(x=-2;x++<9;)s+=x>y?(Math.PI+'2384626433832795028841971693')[n++]:`\\${y>8?'__':x+1|y>2?'::':'||'}\\`[y-x]||' ';console.log(s)

파이썬 2, 131 바이트

print'()'*6+'\n|\\3.1415926|\n|:\\53589793|'
for n in 2384626,433832,79502,8841,971,69,3,'':print'%11s|'%('\%s'*2%('_:'[n<'']*2,n))

Sp3000과 Lynn의 공동 노력. 구리도 바이트를 절약했습니다! 이데온 링크.

/// , 129127 바이트

/-/\\\\//&/--::--//%/  //#/|
%//!/()()/!!!
|-3.1415926|
|:-53589793|
&2384626|
 &433832#&79502# &8841#%&971#% &69#%%&3#%% -__-|

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

배쉬, 153 바이트

cat << _
()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
_

배치, 195 바이트

@echo ()()()()()()
@echo ^|\3.1415926^|
@echo ^|:\53589793^|
@set i=\
@for %%d in (2384626 433832 79502 8841 971 69 3)do @call:l %%d
@echo %i%__\^|
@exit/b
:l
@set i= %i%
@echo%i%::\%1^|

Turtlèd , 135 129 바이트 (경쟁없는)

(인터프리터는 실제로 약간 버그가 없지만 (더 이상 :]) 이 프로그램에는 영향을 미치지 않습니다. )

프로그램을 재구성하고 재 작성함으로써 나는 6 바이트를 골프를 쳤다

그리고 지금 새로운 설명을해야합니다 ...

그래도 더 짧은 프로브 일 수 있습니다

이 언어에서 가장 좋은 해결책은 원시 데이터를 쓰는 것이 아닙니다. ¯ \ _ (ツ) _ / ¯

#3.141592653589793238462643383279502884197169#")()()()()()">10:[)'|l]:[)d'\l]d"(||"2uuu[|;"::"uuu];>"__"[|r'\d]dl[ l[|.+l][\r]ul]

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

설명

솔직히 이것은 실제 프로그램을 잘 설명하지는 않지만 명령에 대한 힌트를 제공하므로 조금 더 잘 이해할 수 있습니다.

#3.141592653589793238462643383279502884197169# Some pi. Set the string to thing between #s
                                               the last digit was same as first, and the
                                               string wraps, so digit could be removed
")()()()()()"  Write this string, by writing char 1 to current cell, moving right, char 2...

>              turn right

10             set register to ten

:[)'|l]:       move right by amount in register, while current cell isn't ), write |
               and move left. move right by amount in register

[)d'\l]        while cell is not (, move down, write \, move left

d"(||"         move down and string-write "(||"

2              set register to 2

uuu[|;"::"uuu] Move up three, and while the cell is not |, move down by
               register (2), string-write "::", move up three

               Just remember the turtle is currently pointing right, so up is right.

;>"__"         move down by amount in register, turn right, string-write "__"

[|r'\d]dl      while cell is not |{ move right, write \, move down}, move down, left

복잡한 것 : 필수 루프

[ l[|.+l][\r]ul]

현재 셀이 공백이 아닌 동안 {왼쪽으로 이동, 루프 실행 :( 셀이 아닌 동안 | 문자열 변수의 현재 문자 쓰기 (pi 기억), 문자열 포인터 증가, 왼쪽으로 이동), 루프 실행 :( 셀이 아닌 \, 오른쪽으로 이동), 위로 이동, 왼쪽}

푸리에, 196 190 바이트

새로운 기능 알림!

암호

|SaCaaSa|f|~Y0~jY(32aj^~j)|w6(40a41ai^~i)10a~N124a~W92a~S3o46a1415926oWaNaWa58a~CSa53589793oWaNaf2384626oWaNa1wf433832oWaNa2wf79502oWaNa3wf8841oWaNa4wf971oWaNa5wf69oWaNa6wf3oWaNa7wSa95aaSaWa

설명

이 프로그램은 푸리에에서의 함수에 대한 첫 데모입니다.

기능은 다음과 같이 정의됩니다.

|code goes here|f

첫 번째 파이프는 함수 선언을 시작합니다. 그런 다음 파이프 사이에 코드를 넣습니다. 마지막 파이프는 함수 선언을 종료합니다. 마지막으로f 는 함수가 저장되는 변수입니다. 예약 된 함수가 아닌 한 문자가 될 수 있습니다.

예를 들어, 내 코드에서 함수 중 하나는 다음과 같습니다.

|SaCaaSa|f

변수 S는 숫자 92를 C저장하고 숫자 58을 저장합니다.

호출되면 함수는 다음을 출력합니다.

\::\

파이에서 가장 반복되는 것이기 때문입니다.

마찬가지로 출력을 낮추기 위해 루프를 사용했습니다.

6(40a41ai^~i)

코드를 40a41a6 번 반복합니다 . 40a41a자체 출력으로 :

()

따라서 코드를 여섯 번 반복하여 출력하십시오.

()()()()()()

이에 의해 파이의 크러스트를 출력한다.

FourIDE에서 사용해보십시오!

_{파이썬 인터프리터에서 함수를 구현하지 않았 으므로이 프로그램은 http://tryitonline.net에서 작동하지 않습니다.}

Pyth, 89 바이트

J_2K+.n0."09\07´\C2\84J\01£\07Nl:?í"*"()"6Vr9Zp*dJp?!Z\|?qZ9"|:""\::"p\\p:KZ+ZN\|=+ZN=hJ)p*dJ"\__\|"

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

바꾸다 \xx 이 대답의 코드를 복사 / 붙여 넣기하면 해당 ASCII 문자로 (16 진수); SE가 걸러내는 압축 문자열에 인쇄 할 수없는 문자가 들어 있습니다.

설명

J_2        Sets J to -2
  .n0      Pi; returns 3.141592653589793
  ."(...)" Packed string; returns "2384626433832795028841971693"
 +         Concatenation; returns "3.1415926535897932384626433832795028841971693"
K          Sets K to that string
*"()"6     Repetition; returns "()()()()()()", which is implicitly printed with a newline
 r9Z       Range; returns [9, 8, 7, 6, 5, 4, 3, 2, 1] (Z is initialized to 0)
V          Loop through r9Z, using N as the loop variable
  *dJ      Repetition; d is initialized to " " (returns an empty string if J <= 0)
 p         Print without a newline
  ?!Z      Ternary; if not Z
   \|      then return "|"
   ?qZ9    else, ternary; if Z == 9
    "|:"   then return "|:"
    "\::"  else, return "\::"
 p         Print without a newline
  \\       One-character string; returns "\"
 p         Print without a newline
  :KZ+ZN   Slice; returns K[Z:Z+N], not including K[Z+N]
 p         Print without a newline
 \|        One-character string; returns "|", which is implicitly printed with a newline.
 =+ZN      Adds N to Z
 =hJ       Increments J by 1
)          Ends loop
 *dJ       Repetition; d is initialized to " "
p          Print without a newline
"\__\|"    Returns "\__\|", which is implicitly printed with a newline

젤리 , 83 바이트

확실히 여전히 골프 공

7Ḷ⁶ẋ;€“\::\”“|:\”ṭṙ7
⁾()ẋ6⁷⁾|\8ØPæp”|⁷8RUR€µ“⁾ḅ|Za"~ṅỵþȷ^ṇ⁷Ċ’Dṁ;€”|ż@¢Y⁷ø⁶ẋ7“\__\|”

TryItOnline

어떻게?

7Ḷ⁶ẋ;€“\::\”“|:\”ṭṙ7 - Link 1, left side padding and filling
7Ḷ                   - lowered range of 7 ([0,1,2,3,4,5,6])
      “\::\”         - filling ("\::\")
  ⁶ẋ;€               - space character repeated that many times and concatenate for each
            “|:\”    - top crust edge filling ("|:\")
                 ṭ   - tack (append to the end)
                  ṙ7 - rotate to the left by 7 (move top crust filling to the top)

⁾()ẋ6⁷⁾|\8ØPæp”|⁷8RUR€µ - Main Link (divided into two for formatting)
⁾()ẋ6⁷                  - "()" repeated 6 times and a line feed
      ⁾|\               - "|\"
          ØP            - pi
         8  æp          - round to 8 significant figures (top edge of the glaze)
              ”|⁷       - "|" and a line feed
                 8R     - range of 8 ([1,2,3,4,5,6,7,8])
                   U    - reverse ([8,7,6,5,4,3,2,1])
                    R€  - range for each ([[1,2,..8],[1,2,..7],...,[1,2],[1]])
                      µ - monadic chain separation

“⁾ḅ|Za"~ṅỵþȷ^ṇ⁷Ċ’Dṁ;€”|ż@¢Y⁷ø⁶ẋ7“\__\|” - Main link (continued)
“⁾ḅ|Za"~ṅỵþȷ^ṇ⁷Ċ’                       - base 250 representation of the rest of the digits
                 D                      - decimalise (makes it a list)
                  ṁ                     - mould (into the shape of the array formed above)
                     ”|                 - "|"
                   ;€                   - concatenate for each
                         ¢              - call last link (1) as a nilad
                       ż@               - zip (with reversed operands)
                          Y⁷            - join with line feeds, and another line feed
                            ø           - niladic chain separation
                             ⁶ẋ7        - space character repeated 7 times
                                “\__\|” - "\__\|" the very bottom of the pie wedge

파이썬 2, 193 176 바이트

P="3.1415926 53589793 2384626 433832 79502 8841 971 69 3".split()
f="()"*6+"\n|\%s|\n|:\%s|\n"%(P[0],P[1])
for s in range(7):f+=" "*s+"\::\\"+P[s+2]+"|\n"
print f+" "*7+"\__\|"

더 짧고 지루한 대답 :

print r"""()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|"""

C # 220 213 209 208 202 201 _{(171 *)} 바이트

* 이것은 독창적이고 부정 행위 인 것으로 보입니다.

void F()=>Console.Write(@"()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|");

201 바이트 :

void f(){var s="()()()()()()\n";for(int i=0;i<9;)s+=(i<1?"|":i<2?"|:":"\\::".PadLeft(i+1))+$"\\{new[]{3.1415926,53589793,2384626,433832,79502,8841,971,69,3}[i++]}|\n";Console.Write(s+@"       \__\|");}

220 바이트 :

나는 여기에 골프가 될 것이 확실하다

void f(){string s="()()()()()()\n",x="       ";for(int i=9,j=0;i>0;j+=i--)s+=(i>7?"|"+(i<9?":":"")+"\\":x.Substring(i)+@"\::\")+$"{Math.PI}32384626433832795028841971693".Substring(j,i)+"|\n";Console.Write(s+x+@"\__\|");}

PowerShell , 105 바이트

'()'*6
'|\3.1415926|
|:\53589793|'
2384626,433832,79502,8841,971,69,3|%{" "*$i+++"\::\$_|"}
' '*7+'\__\|'

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

이 도전에 어떻게 대답하지 못했는지 잘 모르겠습니다 ... 나는 그 도전과 다른 여러 대답을 찬성했습니다. 글쎄요, 늦지 않는 것보다 늦었나요?

이렇게하면 6 개의 균형 잡힌 parens가 파이프 라인에 문자열로 놓인 다음 다음 두 행의 리터럴 문자열 (2 바이트 절약)이됩니다. 그런 다음 나머지 숫자를 반복하여 각 반복이 앞에 붙은 공백 수를 증가시킵니다 ($i )가\::<number>| . 마지막으로 파이 끝 부분을 만듭니다. 이러한 문자열은 모두 파이프 라인에 남아 있으며 암시 적 Write-Output사이에 줄 바꿈이 있습니다.

파이를 인쇄하는 것보다 39 바이트 더 짧습니다 .

숯 , 31 바이트

×⁶()↙↓¹⁰↖↖¹⁰↓↓²↘⁸Ｍ↑__↖←¤:↗¤ＵＧPi

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

당신은 궁금 할 것입니다 :이 마법은 무엇입니까? 당신은 어떻게 채울 수 ＵＧPi있습니까? Charcoal은 언젠가 더 많은 도전에서 경쟁력을 갖기를 희망하면서 Wolfram Language 지원을 받기 시작했습니다!

이전, 71 바이트

×⁶()↙↓¹⁰↖↖¹⁰↓↓²↘⁸Ｍ↑__↖←¤:↗¤3.141592653589793238462643383279502884197169

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

말 수가 많은

Print(Multiply(6, "()"));
Move(:DownLeft)
Print(:Down, 10)
Move(:UpLeft)
Print(:UpLeft, 10)
Move(:Down)
Print(:Down, 2)
Print(:DownRight, 8)
Move(:Up)
Print("__")
Move(:UpLeft)
Move(:Left)
Fill(":")
Move(:UpRight)
Fill("3.141592653589793238462643383279502884197169")

디버 보시 파이어가 자동으로 문자열을 압축하고 중복 명령을 제거하지 않기 때문에 이것은 다릅니다.

압축 문자열, 52 바이트

×⁶¦()↙↓¹⁰↖↖¹⁰↓↓²↘⁸↑__↖←¤:Ｍ↗¤”i¶∧²uτ¶R›    §Ｑ´⌈#_⮌ＰOÞ”

xxd 출력

0000000: aab6 ba28 291f 14b1 b01c 1cb1 b014 14b2  ...()...........
0000010: 1eb8 125f 5f1c 11ef 3acd 1def 0469 0a01  ...__...:....i..
0000020: b275 f40a 52be 0999 9fa4 d1e0 1a23 5f86  .u..R........#_.
0000030: d04f de04                                .O..

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

PHP, 170 바이트

PHP에 임의의 정밀도 Pi가 없습니까? 계산은 복사 및 붙여 넣기보다 더 많은 공간을 차지합니다. 여기의 마지막 숫자는 반올림되지 않고 잘립니다. 그러나 64 비트 Pi에서는 마지막 숫자가 반올림됩니다.

for(;$i<11;)echo str_pad($i?["\\__\\","|\\","|:\\","\\::\\"][$i>9?0:min(3,$i)].[3.1415926,53589793,2384626,433832,79502,8841,971,69,3][$i-1]."|
":"
",13,$i++?" ":"()",0);

로 실행 php -r '<code>'

주석 처리되지 않은 분석

for(;$i<11;)
    echo str_pad($i?
         ["\\__\\","|\\","|:\\","\\::\\"][$i>9?0:min(3,$i)]
        .[3.1415926,53589793,2384626,433832,79502,8841,971,69,3][$i-1]
        ."|\n"
    :"\n"
    ,13,$i++?" ":"()",0);

파이썬 2, 183 171 바이트

p,d=[2384626,433832,79502,8841,971,69,3],"|\n"
c=("()"*6)+d[1]+"|\\"+`3.1415926`+d+"|:\\"+`53589793`+d
for x in range(7):c+=" "*x+"\\::\\"+`p[x]`+d
print c+" "*7+"\\__\\|"

실제로 영리한 일을하지 않습니다. 큰 문자열을 만든 다음 인쇄합니다.

편집하다

@Lynn의 답변과 학습을 읽은 후 171로 줄었습니다. 당신이 그것을 제안하지 않고 (바이트) 당신에게서 몇 바이트를 훔치는 것이 잘못 된 경우 죄송합니다. 그렇다면 알려 주시면 변경 사항을 롤백하겠습니다.

산출

python pi.pie.py

()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|

루비, 140 (138) 137 바이트

루비 에서이 문제에 대한 나의 해결책은 이것이 나의 첫 번째 코드 골프 답변입니다 .D

[0,2384626,433832,79502,8841,971,69,3,1].map{|n|puts n<1?"()"*6+"\n|\\3.1415926|\n|:\\53589793|":"\\#{n>1?"::\\#{n}":"__\\"}|".rjust(12)}

읽을 수있는 버전 및 설명 :

for n in [-1,2384626,433832,79502,8841,971,69,3,0]
  if n < 0 # n == -1
    puts "()"*6+"\n|\\3.1415926|\n|:\\53589793|"
  else
    if n > 0 # digits of pi
      puts "\\::\\#{n}|".rjust(12)
    else # edge of pie
      puts "\\__\\|".rjust(12) 
    end
  end
end

간단한 루프를 사용하여 실제로 영리한 것은 없습니다. :)

산출:

()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|

Stax , 63 바이트

ü?½Pi<Θ*q}ü¿▒5Ç>cdƒ±<Gw►,─ô╟▒g•iâÑ♠514Φ⌂!Ñεùáèè♂ÑD╔«dÿ47¡ô#UV•╧

온라인으로 실행하고 디버그하십시오!

허용 된 MATL 답변보다 짧습니다. Stax에서 더 많은 숫자가 상수 pi로 저장되어 있으면 확실히 더 짧을 것입니다.

( Pi<0코드에서 무엇입니까 ?)

설명

설명하는 데 ASCII를 사용합니다.

.()6*PVP$2ME.|\a+"|:\"a+"!RNyb2L$-!mV=223w+&O-"!{"\::\"s$+mELr"\__\"]+|>m'|+

설명 :

.()6*PVP$2ME.|\a+"|:\"a+
.()                           "()"
   6*P                        Print 6 times
      VP$                     First two lines of pi in the output
         2ME                  Push the two lines separately on the stack
            .|\a+             Prepend the first line with "|\"
                 "|:\"a+      Prepend the second line with "|:\"

"..."!{"\::\"s$+mELr"\__\"]+|>m'|+
"..."!                                [2384626,433832,79502,8841,971,69,3]
      {"\::\"s$+m                     Convert each element to a string and prepend "\::\"
                 ELr                  Prepend the first two lines to array
                    "\__\"]+          Append "\__\" to the converted array
                            |>        Right align text
                              m'|+    Append "|" to each array element and print

자바 7, 260 236 191 바이트

String d(){return"()()()()()()\n|\\3.1415926|\n|:\\53589793|\n\\::\\2384626|\n \\::\\433832|\n  \\::\\79502|\n   \\::\\8841|\n    \\::\\971|\n     \\::\\69|\n      \\::\\3|\n       \\__\\|";}

. 한숨, 단순히 ...>도 모든 이스케이프 백 슬래시, 파이는 짧은 출력>
다음은, 여유의 작은 비트와 이전의 대답은 여전히 매우 일반적인하지 않거나 공상 (비록 236 바이트 ) :

String c(){String n="\n",p="|",q=p+n,x="\\::\\",s=" ",z=s;return"()()()()()()"+n+p+"\\"+3.1415926+q+p+":\\53589793"+q+x+2384626+q+s+x+433832+q+(z+=s)+x+79502+q+(z+=s)+x+8841+q+(z+=s)+x+971+q+(z+=s)+x+69+q+(z+=s)+x+3+q+(z+=s)+"\\__\\|";}

너무 많은 멋진 일없이 단순히 결과를 출력하는 것이 일반적인 접근법보다 Java에서 더 짧기 때문에 꽤 지루한 대답입니다.

언 골프 및 테스트 코드 :

여기에서 시도하십시오.

class M{
  static String c(){
    String n = "\n",
           p = "|",
           q = p + n,
           x = "\\::\\",
           s = " ",
           z = s;
    return "()()()()()()" + n + p + "\\" + 3.1415926 + q + p + ":\\53589793" + q + x + 2384626 + q + s
            + x + 433832 + q + (z += s) + x + 79502 + q + (z += s) + x + 8841 + q 
            + (z += s) + x + 971 + q + (z += s) + x + 69 + q + (z += s) + x + 3 + q
            + (z += s) + "\\__\\|";
  }

  public static void main(String[] a){
    System.out.println(c());
  }
}

산출:

()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|

Qbasic, 175 바이트

?"()()()()()()":?"|\3.1415926|":?"|:\53589793|":?"\::\2384626|":?" \::\433832|":?"  \::\79502|":?"   \::\8841|":?"    \::\971|":?"     \::\69|":?"      \::\3|":?"       \__\|"

루아, 152 바이트

print[[()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|]]

이 pi를 압축하지 못할 수도 있습니다.

루아는 너무 장황하여 아마도 더 큰 크기의 파이이지만 이것이 아닙니다.

또 다른 해결책은 186 바이트입니다.

s="()()()()()()\n|\\3.1415926|\n|:\\53589793|\n"i=0 for z in('2384626|433832|79502|8841|971|69|3|'):gmatch'.-|'do s=s..(' '):rep(i)..'\\::\\'..z.."\n"i=i+1 end print(s..'       \\__\\|')

성가신 루아의 파이는 파이를 채우기에 충분하지 않습니다. :(

자바 스크립트, 172 바이트

콘솔에 붙여 넣어 실행하십시오.

for(y=n=0,s=`()()()()()()
`;y<10;y++,s+=`|
`)for(x=-2;x++<9;)s+=x>y(Math.PI+'2384626433832795028841971693'[n++]:`\\${y>8?'__':x+1|y>1?'::':'||'}\\`[y-x]||' ';console.log(s)

JavaScript (ES6), 170 바이트 165 바이트

콘솔에서 실행하면 반환 값이 표시되므로 "불량"입니다.

v=0;("()()()()()()\n|9|:87654321".replace(/\d/g,(o)=>"\\"+(Math.PI+'2384626433832795028841971693').substr(v,o,v-=-o)+"|\n"+(o<9?" ".repeat(8-o)+(o>1?"\\::":"\\__\\|"):""))

티킹 후 함수는 다음과 같습니다 (함수는 값이 0 인 매개 변수와 함께 호출되어야 함).

v=>`()()()()()()
 |9 |:87654321\\__\\|`.replace(/\d/g,o=>`\\${(Math.PI+"2384626433832795028841971693").substr(v,o,v-=-o)}|
${" ".repeat(9-o)+(o<9&o>1?"\\::":"")}`)

함수 167 바이트를 호출하려는 경우 :

z=v=>`()()()()()()
 |9 |:87654321\\__\\|`.replace(/\d/g,o=>`\\${(Math.PI+"2384626433832795028841971693").substr(v,o,v-=-o)}|
${" ".repeat(9-o)+(o<9&o>1?"\\::":"")}`)


/*could be run like this or directly in the console*/
console.info("\n"+z(0));

PHP, 142 바이트

Sneaky-sneaky :) 쌍을 php찾지 못하면 PHP 코드로 해석하지 않고 모든 것을 인쇄합니다 <?php ?>.

()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|