เขียนโปรแกรมหรือฟังก์ชั่นที่พิมพ์หรือพิมพ์ข้อความที่แน่นอน (ประกอบด้วย 142 ตัวอักษร):

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

โปรแกรมของคุณต้องไม่ป้อนข้อมูล (ยกเว้นในภาษาที่เป็นไปไม่ได้เช่นsed) และสร้างข้อความด้านบน (และเฉพาะข้อความด้านบน) เป็นผลลัพธ์ บรรทัดใหม่ต่อท้ายเป็นที่ยอมรับ

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุด (เป็นไบต์) ชนะ

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)

Perl, 93 ไบต์

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

ต้องใช้ตัวเลือกบรรทัดคำสั่ง-l71Mbignum=bpiซึ่งนับเป็น 14 \32ควรแทนที่ด้วยตัวอักษร 26

ตัวอย่างการใช้งาน

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

Perl, 111 ไบต์

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

รุ่นพารามิเตอร์ ต้องใช้ตัวเลือกบรรทัดคำสั่ง-nMbignum=bpiนับเป็น 12

ตัวอย่างการใช้งาน

$ 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|
               \__\|

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

Python 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 ทองแดงบันทึกไบต์ด้วยเช่นกัน! ลิงค์ Ideone

/// , 129 127 ไบต์

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

ลองออนไลน์!

Bash, 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 ไบต์ (ไม่ใช่การแข่งขัน)

(ล่ามไม่ได้เป็นbuggèd จริง ๆเล็กน้อย (อีกต่อไป:]) แต่ไม่มีผลกับโปรแกรมนี้ )

ด้วยการปรับโครงสร้างและเขียนโปรแกรมของฉันใหม่ฉันเล่นกอล์ฟ ... หกไบต์

และตอนนี้ฉันต้องอธิบายใหม่ ...

ยังคงเป็นโพรบที่สั้นกว่าได้

อย่างน้อยที่สุดทางออกที่ดีที่สุดใน lang นี้ไม่เพียงเขียนในข้อมูลดิบ¯ \ _ (ツ) _ / ¯

#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!

_{เนื่องจากฉันไม่ได้ใช้ฟังก์ชั่นในตัวแปล Python โปรแกรมนี้จึงไม่สามารถใช้งานได้ใน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 ที่เกี่ยวข้องหากคุณคัดลอก / วางรหัสจากคำตอบนี้ มันมีอักขระที่ไม่สามารถพิมพ์ได้ในสตริงที่บรรจุซึ่ง 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 ไบต์

แน่นอนว่ายังค่อนข้าง golfabale

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

Python 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+'\__\|'

ลองออนไลน์!

ไม่แน่ใจว่าฉันไม่เคยตอบคำถามนี้ได้อย่างไรฉันลุกขึ้นสู้และตอบคำถามอีกหลายข้อ ดีกว่าไม่สาย

สิ่งนี้ทำให้ parens ที่สมดุลหกตัวเป็นสตริงบนไพพ์ไลน์จากนั้นสตริงตัวอักษร (บันทึกสองไบต์) ของสองแถวถัดไป จากนั้นเราจะห่วงผ่านส่วนที่เหลือของตัวเลขแต่ละย้ำการเพิ่มจำนวนของช่องว่าง prepended (คน$i) \::<number>|ต่อกันด้วย สุดท้ายเราสร้างสตริงของปลายพาย สตริงเหล่านั้นทั้งหมดที่เหลืออยู่บนท่อและนัยWrite-Outputเกาะติดขึ้นบรรทัดใหม่ระหว่าง

นี่คือ 39 ไบต์ที่สั้นกว่าเพียงแค่พิมพ์วงกลม

ถ่าน 31 ไบต์

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

ลองออนไลน์!

คุณอาจสงสัยว่าคาถานี้คืออะไร? คุณเติมได้ＵＧPiอย่างไร? ถ่านก็เริ่มที่จะได้รับการสนับสนุนภาษา Wolfram ด้วยความหวังว่าวันหนึ่งมันจะสามารถแข่งขันในความท้าทายมากขึ้น!

ก่อนหน้านี้ 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")

โปรดทราบว่าสิ่งนี้จะแตกต่างกันเนื่องจาก deverbosifier บีบอัดสตริงโดยอัตโนมัติและไม่ลบคำสั่งซ้ำซ้อน

ด้วยสตริงที่บีบอัด 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? การคำนวณใช้เนื้อที่มากกว่าการคัดลอกและวาง ไม่สำคัญว่าตัวเลขสุดท้ายที่นี่ถูกตัดแล้วไม่ถูกปัดเศษ แต่ใน 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);

Python 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+"\\__\\|"

ไม่ได้ทำอะไรที่ฉลาดจริงๆ เพียงสร้างสตริงขนาดใหญ่แล้วพิมพ์ออกมา

แก้ไข

ลดเหลือ 171 หลังจากอ่านคำตอบและการเรียนรู้ของ @ Lynn ขออภัยถ้ามันผิดที่จะขโมยบางอย่างจากคุณโดยที่คุณไม่ได้แนะนำ โปรดบอกฉันถ้าเป็นเช่นนั้นและฉันจะย้อนกลับการเปลี่ยนแปลง

เอาท์พุต

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 ที่ยอมรับ มันจะสั้นลงอย่างแน่นอนหากเก็บตัวเลขไว้เป็นค่า pi คงที่ใน Stax

(นั่นคืออะไรPi<0ในรหัส?)

การอธิบาย

ใช้ ASCII ที่เทียบเท่าเพื่ออธิบายซึ่งก็คือ

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

Expalantion:

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

Java 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       \\__\\|";}

. เฮ้อเพียง outputting พายสั้นแม้จะมีทั้งหมด backslashes หนี .. >>
นี่คือคำตอบก่อนหน้านี้ด้วยบิตเล็ก ๆ ของที่แม้ว่าจะยังไม่ทั่วไปมากหรือแฟนซี ( 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)+"\\__\\|";}

คำตอบที่น่าเบื่อเนื่องจากการแสดงผลลัพธ์โดยที่ไม่มีสิ่งแฟนซีมากเกินไปในภาษาจาวาจึงสั้นกว่าวิธีทั่วไป

Ungolfed & รหัสการทดสอบ:

ลองที่นี่

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|":?"       \__\|"

Lua, 152 ไบต์

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

พยายามอย่างที่ฉันไม่สามารถบีบอัด pi

Lua เป็นเพียง verbose เกินไปที่จะทำมันอาจจะเป็นไพขนาดใหญ่กว่า แต่ไม่ใช่อันนี้

อีกวิธีการแก้ปัญหา 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..'       \\__\\|')

Pi ที่น่ารำคาญของ Lua นั้นไม่แม่นยำพอที่จะเติมไพ :(

Javascript, 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 ไบต์

ส่อเสียด :) phpเพียงพิมพ์ทุกอย่างออกมาโดยไม่พยายามตีความมันเป็นรหัส PHP ถ้ามันไม่เห็น<?php ?>คู่ใด ๆ

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