烤一片Pi

82

编写一个程序或函数来打印或输出此准确的文本（由142个字符组成）：

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

您的程序必须不接受任何输入（除非使用不可能的语言，例如sed），并产生以上文本（并且仅上面的文本）作为输出。尾随换行符是可以接受的。

这是代码高尔夫球，因此最短的答案（以字节为单位）获胜。

code-golf  ascii-art  kolmogorov-complexity  pi 
— 铜
source
9
@RohanJhunjhunwala为了证明可以将其压缩，Luis Mendo做到了。
— 暴民埃里克（Erik the Outgolfer）'16
1
大声笑，我被证明是错的（我很高兴！）非常令人印象深刻
— Rohan Jhunjhunwala
2
您很冷，让他们采用整数输入N来输出()顶部的数字为N的切片。这非常复杂。
— user6245072
5
请注意，您需要π的43个小数位。
— 暴民埃里克
4
如此接近生命的意义......
— A.米拉波

Answers:

90

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)
— 路易斯·门多
source
14
路易斯·门多（Luis Mendo），这令人印象深刻。如果可以的话，我将投票两次。我认为这将是不可压缩的科摩戈罗夫挑战。谢谢你证明我错了！
— Rohan Jhunjhunwala
3
@Rohan谢谢您的客气！
— 路易斯·门多
1
：D没问题！：D
— Rohan Jhunjhunwala
3
+1（:)显示在您的代码中）。
— Erik the Outgolfer
2
@Neil看到生活的光明面...
— 暴民埃里克
37

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|
               \__\|
— 原始
source
25

的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)
展开摘要

— Arnauld
source
1
它不是比console.log（“”）+ 12 * 11个字符+ 18个反斜杠+ 10个换行符短一个字节吗？
— 泰特斯（Titus）2013年
@Titus-你是对的。我忘了算反斜杠转义。谢谢！
— Arnauld
18
温和有趣，但2384626433832795028841971693恰好是最好的。
— ElementW
1
@ElementW-有趣的是您提到了它，因为我也做了检查。:)
— Arnauld
将数字写为十六进制并将其转换为字符串会节省任何字节吗？
— Nic Hartley
17

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链接。

— 林恩
source
雅致+1
— ElPedro
通过删除for循环中的括号，您应该能够节省1个字节。
— 铜
16

///，129127字节

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

在线尝试！

— 暴民埃里克
source
-2个字节（如果您/!/()()/!!!代替()()()()()()并替换为/#/|\n%%/，/#/|\n%/并调整其余代码以使其起作用）。
— acrolith
@daHugLenny哦，谢谢，我不知道4 * 3是替换的有效候选人。对于您的第二个建议，我认为它会更长。
— 暴民埃里克
@daHugLenny ^^我可以确认您的第二个建议确实更长。
— Erik the Outgolfer
— acrolith
@DestructibleWatermelon我故意这样做。也有其他的面孔：-:，:-，:-和-__-。
— 暴民埃里克
12

Bash，153个字节

cat << _
()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
_
— 克里斯
source
9
考虑到还有多少其他答案陷入比编写文字饼图更长的代码生成陷阱中，我认为这确实是一个明智的答案。而且，按我的计数，它只有153个字节。
— 林恩
3
@Lynn但是，它只是将示例转储到输出中，而没有打高尔夫球的尝试，因此不建议这样做。至少其他答案也付出了努力……
— Beta Decay 2016年
您可以删除<<。之前和之后的空格。您的字节数为153个字节。
— TuxCrafting
1
是不是echo '()()()()()()...\__\|'4个字节的短？
— 尼尔
@Lynn我很高兴我没有那个问题；批处理需要100字节的开销才能简单地打印饼图。
— 尼尔
9

批次，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^|
— 尼尔
source
5

Turtlèd，135个 129字节（不竞争）

（解释并不是真正略有窃听（再：]），但它不影响这个程序）

通过重组和重写程序，我打了高尔夫……六个字节

现在我必须做出新的解释...

仍然可能是更短的概率

至少在此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]

当当前单元格不是空格时{向左移动，执行循环：（而单元格不是|，写入字符串变量的当前char（记住pi？），递增字符串指针，向左移动），执行循环：（而单元格不是\，向右移动），向左移动}

— 破坏性柠檬
source
为什么不竞争？
— 程序员
不竞争意味着它比挑战要新
— 破坏的柠檬
5

傅立叶，196190字节

新功能警报！

码

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

说明

该程序是我对Fourier函数的首次演示：

函数的定义如下：

|code goes here|f

第一个管道开始函数声明。然后，将代码放在管道之间。最后一个管道结束函数声明。最后，f是存储函数的变量。只要不是保留函数，就可以是任何字符。

例如，在我的代码中，函数s之一是：

|SaCaaSa|f

变量S存储数字92和C存储数字58。

调用时，该函数输出以下内容：

\::\

因为这是馅饼中最重复的东西。

同样，为了降低输出，我使用了一个循环：

6(40a41ai^~i)

重复代码40a41a6次。40a41a根据自己的输出：

()

因此，将代码重复六次输出：

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

从而输出馅饼的外壳。

在FourIDE上尝试！

由于我尚未在Python解释器中实现函数，因此该程序无法在http://tryitonline.net上运行

— Beta衰变
source
4

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
— insert_name_here
source
4

果冻，83 个字节

当然还是蛮高尔夫的

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

在线试用

怎么样？

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
— 乔纳森·艾伦
source
2
哇，那是我见过的最长的果冻程序：o
— Beta Decay
@BetaDecay毫无疑问，它可以用11个字节完成...
— Jonathan Allan
3

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|
       \__\|"""
— 杂种
source
3
您知道print r'''(the pie)'''短38个字节吗？:)
— 林恩
+1是您的第二个努力，但使用单引号会使查看时间更短。像素数更好：)
— ElPedro
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+@"\__\|");}
— pinkfloydx33
source
感谢您的回答！您可以通过删除中的多余空间来节省至少一个字节.Substring(j, i)。
— 铜
那是对VS中自动格式化的一个疏忽，但是无论如何我还是节省了一大堆=）
— pinkfloydx33
逐字返回饼图的匿名函数要短25％以上：()=>@"(pie)"149个字节。
— 林恩
它也很无聊，感觉就像在作弊。规则说要打印，而不要退货
— pinkfloydx33
@ pinkfloydx33 根据社区共识，默认情况下均允许打印和返回。
— mbomb007'9
3

PowerShell，105字节

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

在线尝试！

不知道我如何从未回答过这个挑战……我赞成它以及其他几个答案。噢，迟到总比不到好吗？

这会将六个平衡的paren作为字符串放在管道上，然后是接下来的两行的文字字符串（节省两个字节）。然后，我们遍历其余数字，每次迭代都会增加与$i串联的前置空格（）的数量\::<number>|。最后，我们创建一串馅饼的尖端。这些字符串都留在管道上，并且隐式Write-Output之间插入换行符。

这比仅打印饼图要短39个字节。

— AdmBorkBork
source
3

木炭，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")

请注意，这是不同的，因为去副音符会自动压缩字符串，并且不会删除多余的命令。

使用压缩字符串时，为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..

在线尝试！

— 仅ASCII
source
2

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);
— 提图斯
source
输出缺少1个空间（可以通过改变固定13用14）。而且，由于某些奇怪的原因，您在顶部缺少右括号。进行更改可修复输出。
— Ismael Miguel
PHP答案需要一个<?php标签，否则它们只会产生恒定的输出。PHP您好，世界！实际上取决于此。但是，就恒定输出而言，仅包含文字蛋糕而根本没有<?php标签的PHP答案将大大击败您的…
— Lynn
@Lynn：使用以下命令运行PHP <?php时不需要标记-r。
— 泰特斯（Titus）
2

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

确实没有做任何聪明的事情。只需构建一个大字符串然后将其打印出来即可。

编辑

阅读@Lynn的答案并学习后减少到171。很抱歉，如果不建议您（无耻地）窃取一些字节是错误的。请告诉我是否这样做，我会回滚更改。

输出量

python pi.pie.py

()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
— 埃尔佩德罗
source
您知道print r'''(the pie)'''短28个字节吗？:)
— 林恩
@Lynn这不是作弊吗？;-)
— ElPedro
这不是作弊，只是不是很有趣（IMO，我们不需要每种语言的答案。bash的答案就足够了）。更像是您在发布这样的答案时想要提及的东西，以承认您的高尔夫尝试最终是一种损失。也许仍然值得发布，以防其他人看到一种采纳您的高尔夫想法并加以改进的方法，也许击败了幼稚的方法。
— 彼得·科德斯
我在@Peter上接受您的评论。因此，我并不是想对别人不敬。任何人都可以像这样打印出ASCII艺术挑战。我对此很陌生，可以在这里学习。如果有什么用，我看到林恩的答案不仅是书面声明，而且以完全超出了我的努力的方式解决了该问题，则在Lynn的回答上加了评论并+1。我学到了...
— ElPedro
只要您的答案仍然采用不同的方法，就可以从其他答案（无论是否使用相同语言）中获取想法。唯一不能接受的是，如果您的答案最终得到的代码与Lynn的代码完全相同。通常，如果您发现别人的答案有小幅改进，则建议在评论中提出。但是，如果在看到其他人的答案后有多个新想法，您甚至可以将改进的版本发布为新答案。我不太确定这方面的礼节，但我认为只要您的回答有明显不同，就可以了。
— 彼得·科德斯
2

红宝石，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|
       \__\|
— 莱纳斯
source
2
欢迎来到PPCG！不错的第一篇文章！
— Rɪᴋᴇʀ
2

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
— 周卫军
source
1

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

。感叹，简单地输出馅饼较短，即使所有的转义反斜线。>>
这里是以前的答案用得起的一点点，虽然还不是很一般的或花哨（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|
       \__\|
— 凯文·克鲁伊森
source
1

Qbasic，175个字节

?"()()()()()()":?"|\3.1415926|":?"|:\53589793|":?"\::\2384626|":?" \::\433832|":?"  \::\79502|":?"   \::\8841|":?"    \::\971|":?"     \::\69|":?"      \::\3|":?"       \__\|"
— 匿名2
source
1

Lua，152字节

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

请尝试，因为我可能无法压缩此pi。

Lua太冗长，无法做到这一点，可能是更大的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..'       \\__\\|')

恼人的是Lua的pi不够准确，甚至无法填满pi。:(

— 阿塔科
source
1

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)
— 卡贾尔（Kajal Chaudhari）
source
欢迎来到PPCG！就是这样，您可以用四个空格格式化代码（请参阅我的编辑）。另外，将程序中的字节数放在答案的顶部（例如Javascript: 100 bytes）。
— Qwerp-Derp
似乎有奇怪的语法错误，您可以解决这些错误吗？
— 程序员
1

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));
展开摘要

— Winner_Joiner
source
1：需要额外的结束时间。2：将文字换行符替换"|\n"为|<newline>where <newline>。3：从头y=>开始，不会作弊。4：欢迎光临本站！
— 程序员
1
@ programmer5000感谢您的输入，我在最近的调整中使用了它。:-D
— winner_joiner
删除()封闭的v参数可节省2个字节。您的输出似乎在第二和第三行的前面有多余的空间。另外，您不需要传递0参数，没有它就可以正常工作，并且挑战也不允许这样做。
— 毛茸茸的
是的，谢谢，我有默认值。:-D
— winner_joiner
0

PHP，142字节

Sneaky-sneaky :) php只是打印出所有内容，如果看不到任何<?php ?>对，则不会尝试将它们解释为PHP代码。

()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
— iBug
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.