Hornear una rodaja de pi

82

Escriba un programa o función que imprima o muestre este texto exacto (que consta de 142 caracteres):

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

Su programa no debe tomar ninguna entrada (excepto en idiomas donde esto es imposible, como sed) y producir el texto anterior (y solo el texto anterior) como salida. Una nueva línea final es aceptable.

Este es el , por lo que gana la respuesta más corta (en bytes).

Cobre
fuente
99
@RohanJhunjhunwala Para probar que esto se puede comprimir, Luis Mendo lo hizo .
Erik the Outgolfer
1
Lol, se me demostró que estaba equivocado (¡y me alegro!) Muy impresionante
Rohan Jhunjhunwala
2
Usted ha hecho que tomen una entrada entera N para generar una porción cuyo número ()en la parte superior es N. Sería muy complejo.
user6245072
55
Para que lo sepas, necesitas 43 decimales de π.
Erik the Outgolfer
44
Tan cerca del significado de la vida ...
A. Mirabeau

Respuestas:

90

MATL , 70 68 67 bytes

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

Pruébalo en línea!

Explicación

Que desastre. Pero bueno, ¡hay una convolución!

La explicación será más clara si puede inspeccionar el contenido de la pila después de una declaración dada . Para hacerlo, simplemente inserte X#0$%en ese punto. (Esto significa: X# mostrar el contenido de la pila, 0$no mostrar implícitamente nada más, %comentar el resto del código). Por ejemplo, vea la pila justo después de la convolución .

'()'       % 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)
Luis Mendo
fuente
14
Luis Mendo, esto es impresionante. Votaría dos veces si pudiera. Pensé que esto sería un desafío incompresible kolmogorov. ¡Gracias por demostrarme que estoy equivocado!
Rohan Jhunjhunwala
3
@Rohan ¡Gracias por tus amables palabras!
Luis Mendo
1
: D ¡No hay problema! : D
Rohan Jhunjhunwala
3
+1 para el :)que aparece en su código.
Erik the Outgolfer
2
@Neil Vea el lado positivo de la vida ...
Erik the Outgolfer
37

Perl, 93 bytes

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

Requiere la opción de línea de comando -l71Mbignum=bpi, contada como 14. El \32debe ser reemplazado por un carácter literal 26.

Uso de muestra

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

Perl, 111 bytes

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

Versión parametrizada. Requiere la opción de línea de comando -nMbignum=bpi, contada como 12.

Uso de muestra

$ 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|
               \__\|
primo
fuente
25

JavaScript (ES6), 187 174 bytes

Esto es 1 byte más corto que solo mostrar el texto sin formato.

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
fuente
1
¿No es un byte más corto que console.log ("") + 12 * 11 caracteres + 18 barras invertidas + 10 saltos de línea?
Tito
@Titus - Tienes razón. Olvidé contar el escape de la barra invertida. ¡Gracias!
Arnauld
18
Un poco interesante, pero 2384626433832795028841971693 resulta ser primo.
ElementW
1
@ElementW - Es curioso que lo hayas mencionado, porque también lo comprobé :)
Arnauld
¿Escribir el número como hexadecimal y convertirlo en una cadena ahorrará bytes?
Nic Hartley
17

Python 2, 131 bytes

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

Esfuerzo conjunto entre Sp3000 y Lynn. ¡Copper también salvó un byte! Ideone link.

Lynn
fuente
Eso es elegante +1
ElPedro
Debería poder guardar 1 byte quitando los corchetes en el forbucle.
Cobre
16

/// , 129 127 bytes

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

Pruébalo en línea!

Erik el Outgolfer
fuente
-2 bytes si lo hace en /!/()()/!!!lugar de ()()()()()()y reemplaza /#/|\n%%/con /#/|\n%/y ajusta el resto del código para que funcione con eso.
acrolith
@daHugLenny Oh, gracias, no sabía que 4 * 3 era un candidato válido para el reemplazo. Para su segunda sugerencia, creo que será más larga.
Erik the Outgolfer
@daHugLenny ^^ Puedo confirmar que su segunda sugerencia es más larga.
Erik the Outgolfer
@DestructibleWatermelon Lo hice intencionalmente. También hay otras caras: -:, :-, :-y -__-.
Erik the Outgolfer
12

Bash, 153 bytes

cat << _
()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
_
Chris
fuente
99
Teniendo en cuenta cuántas de las otras respuestas cayeron en la trampa de producir código más tiempo que imprimir el pastel literal , creo que esta es una respuesta inteligente. Además, son solo 153 bytes por mi cuenta.
Lynn
3
@ Lynn Sin embargo, solo está volcando el ejemplo a la salida sin ningún intento de jugar al golf, por lo que se desaconseja. Al menos las otras respuestas hicieron un esfuerzo ...
Beta Decay
Puede eliminar los espacios antes y después de <<. Y su bytecount es de 153 bytes.
TuxCrafting
1
¿No son echo '()()()()()()...\__\|'4 bytes más cortos?
Neil
@ Lynn Me alegro de no haber tenido ese problema; El lote requiere 100 bytes de sobrecarga para imprimir simplemente el pastel.
Neil
9

Lote, 195 bytes

@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^|
Neil
fuente
5

Turtlèd , 135 129 bytes (no compite)

(el intérprete ya no está ligeramente molesto (más:]) , pero no afecta a este programa )

Al reestructurar y reescribir mi programa, jugué al golf ... seis bytes

Y ahora tengo que hacer una nueva explicación ...

Sin embargo, aún podrían ser problemas más cortos


Al menos la mejor solución en este idioma no es solo escribir en los datos sin procesar ¯ \ _ (ツ) _ / ¯


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

Pruébalo en línea

Explicación

Honestamente, esto no describe el programa real muy bien, pero da pistas sobre los comandos, por lo que es posible que comprenda un poco mejor

#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

Cosa compleja: bucles anidados

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

Mientras que la celda actual no es espacio {mueva hacia la izquierda, ejecute el bucle: (Mientras la celda no es |, escriba el carácter actual de la variable de cadena (recuerde que pi?), Incremente el puntero de cadena, mueva a la izquierda), ejecute el bucle: (mientras que la celda no \, mover hacia la derecha), hacia arriba, hacia la izquierda}

Limón Destructible
fuente
¿Por qué no competir?
programmer5000
no competir significa que es más nuevo que el desafío
Destructible Lemon
5

Fourier, 196 190 bytes

Nueva función de alerta!

Código

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

Explicación

Este programa es mi primera demostración de funciones en Fourier:

Las funciones se definen así:

|code goes here|f

La primera tubería inicia la declaración de función. Luego pones el código entre las tuberías. La última tubería finaliza la declaración de función. Finalmente, fes la variable en la que se almacena la función. Este puede ser cualquier carácter, siempre que no sea una función reservada.

Por ejemplo, en mi código, una de las funciones es:

|SaCaaSa|f

Donde la variable Salmacena el número 92 y Calmacena el número 58.

Cuando se llama, la función genera lo siguiente:

\::\

Ya que es lo más repetido en el pastel.

Del mismo modo, para jugar golf en la salida, he usado un bucle:

6(40a41ai^~i)

Que repite el código 40a41a6 veces. 40a41aen sus propias salidas:

()

Entonces repitiendo el código seis veces salidas:

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

De este modo, saca la corteza del pastel.

Pruébalo en FourIDE!

Como no he implementado funciones en el intérprete de Python, este programa no funcionará en http://tryitonline.net

Decaimiento Beta
fuente
4

Pyth, 89 bytes

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

Pruébalo en línea!

Reemplace \xx(hexadecimal) con el carácter ASCII correspondiente si copia / pega el código de esta respuesta; contiene caracteres no imprimibles en la cadena empaquetada que SE filtra.

Explicación

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
fuente
4

Jalea , 83 bytes

seguramente todavía bastante golfabale

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

TryItOnline

¿Cómo?

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
Jonathan Allan
fuente
2
Wow, ese es el programa Jelly más largo que he visto: o
Beta Decay
@BetaDecay sin duda se puede hacer en 11 bytes ...
Jonathan Allan
3

Python 2, 193 176 bytes

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

O una respuesta más corta y aburrida:

print r"""()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|"""
acrolito
fuente
3
¿Sabías que print r'''(the pie)'''es 38 bytes más corto? :)
Lynn
+1 para su segundo esfuerzo, pero el uso de comillas simples hace que sea más corto de ver. El recuento de píxeles es mejor :)
ElPedro
3

C # 220 213 209 208 202 201 (171 *) Bytes

* Encuentro que esto no es original y hace trampa

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

201 bytes:

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 bytes:

Estoy seguro de que hay algo para jugar golf aquí

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
fuente
¡Gracias por la respuesta! Puede guardar al menos un byte eliminando el espacio adicional .Substring(j, i).
Cobre
Eso fue un descuido del formateo automático en VS, pero de todos modos ahorré un montón de otra manera =)
pinkfloydx33
Una función anónima que devuelve el pie literal es> 25% más corta: ()=>@"(pie)"149 bytes .
Lynn
También es aburrido y se siente como hacer trampa. Las reglas dicen imprimir, no regresar
pinkfloydx33
@ pinkfloydx33 La impresión y la devolución están permitidas por defecto de acuerdo con el consenso de la comunidad.
mbomb007
3

PowerShell , 105 bytes

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

Pruébalo en línea!

No estoy seguro de cómo nunca respondí a este desafío ... Lo voté y varias de las otras respuestas. Oh bueno, mejor tarde que nunca?

Esto pone seis parens balanceados como una cadena en la tubería, luego una cadena literal (ahorra dos bytes) de las siguientes dos filas. Luego, recorremos el resto de los números, cada iteración incrementa el número de espacios prefijados ( $i) concatenados con \::<number>|. Finalmente, creamos una cadena de la punta del pastel. Esas cadenas se dejan en la tubería, y un implícito Write-Outputpega una nueva línea entre ellas.

Esto es 39 bytes más corto que simplemente imprimir el pastel.

AdmBorkBork
fuente
3

Carbón , 31 bytes

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

Pruébalo en línea!

Tal vez se pregunte: ¿qué es esta brujería? ¿Cómo puedes llenar con UGPi? Bueno, Charcoal está comenzando a obtener soporte Wolfram Language, ¡con la esperanza de que algún día pueda ser competitivo en más desafíos!

Anterior, 71 bytes

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

Pruébalo en línea!

Verboso

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

Tenga en cuenta que esto es diferente ya que el desverbosificador comprime automáticamente las cadenas y no elimina los comandos redundantes.

Con cadenas comprimidas, 52 bytes.

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

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

Pruébalo en línea!

Solo ASCII
fuente
2

PHP, 170 bytes

sin precisión arbritrary Pi en PHP? El cálculo ocupa mucho más espacio que Copiar y pegar. No importa que el último dígito aquí esté cortado, no redondeado; pero en Pi de 64 bits, el último dígito se redondea.

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

Corre con php -r '<code>'

desglose no comentado

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);
Titus
fuente
A la salida le falta 1 espacio (que puede solucionar cambiando eso 13con a 14). Y, por alguna extraña razón, te estás perdiendo el paréntesis de cierre en la parte superior. Hacer el cambio corrige la salida.
Ismael Miguel
Las respuestas PHP necesitan una <?phpetiqueta, de lo contrario solo producen resultados constantes. PHP Hola, Mundo! De hecho depende de esto. Sin embargo, hablando de resultados constantes, una respuesta PHP que solo contiene el pastel literal y ninguna <?phpetiqueta vencería a la tuya por un gran margen ...
Lynn
@ Lynn: PHP no necesita la <?phpetiqueta cuando la ejecutas -r.
Tito
2

Python 2, 183 171 bytes

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

Realmente no hace nada inteligente. Simplemente construye una cadena grande y luego la imprime.

EDITAR

Reducido a 171 después de leer la respuesta y el aprendizaje de @ Lynn. Lo sentimos si está mal (descaradamente) robarte algunos bytes sin que lo sugieras. Por favor, dígame si es así y revertiré el cambio.

Salida

python pi.pie.py

()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
ElPedro
fuente
¿Sabes que print r'''(the pie)'''es 28 bytes más corto? :)
Lynn
@ Lynn ¿Eso no es trampa? ;-)
ElPedro
No es trampa, simplemente no es muy interesante (y no necesitamos esa respuesta para todos los idiomas, OMI. La respuesta bash es suficiente). Más como algo que quisiera mencionar al publicar una respuesta como esta, para reconocer que su intento de golf terminó siendo una pérdida. Quizás todavía valga la pena publicar en caso de que alguien más vea una manera de tomar su idea de golf y mejorarla, tal vez superando el enfoque ingenuo.
Peter Cordes
Tomo sus comentarios a bordo @Peter. No estaba tratando de ser irrespetuoso, de ahí la carita sonriente. Cualquiera puede imprimir un desafío de arte ASCII como este. Soy bastante nuevo en esto y estoy aquí para aprender. Si significa algo, puse un comentario y un +1 en la respuesta de Lynn cuando vi que no era solo una declaración impresa, sino que abordé el problema de una manera que superó por completo mi esfuerzo. He aprendido ...
ElPedro
Mientras su respuesta todavía tenga un enfoque diferente, está bien obtener ideas de otras respuestas (en el mismo idioma o no). Lo único que no estaría bien es si su respuesta terminara exactamente con el mismo código que Lynn. Por lo general, si ve una pequeña mejora en la respuesta de otra persona, sugeriría eso en un comentario. Pero si tiene múltiples ideas nuevas después de ver la respuesta de otra persona, incluso puede publicar su versión mejorada como una nueva respuesta. No estoy totalmente seguro de la etiqueta de esto, pero creo que está bien siempre que su respuesta sea significativamente diferente.
Peter Cordes
2

Ruby, 140 138 137 bytes

Mi solución a este problema en ruby, esta es mi primera respuesta de código de golf: 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)}

Versión legible y explicación:

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

Nada realmente inteligente, solo usando algunos bucles simples :)

Salida:

()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
Linus
fuente
2
Bienvenido a PPCG! Bonito primer post!
Rɪᴋᴇʀ
2

Stax , 63 bytes

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

Ejecutar y depurar en línea!

Más corta que la respuesta MATL aceptada. Definitivamente sería más corto si se almacenaran más dígitos como pi constante en Stax.

(¿Qué es eso Pi<0en el código?)

Explicación

Utiliza el equivalente ASCII para explicar, que es

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

Expansión:

.()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
Weijun Zhou
fuente
1

Java 7, 260 236 191 bytes

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

. Suspiro, simplemente haciendo salir el pastel es más corto, incluso con todas las barras invertidas escapado ..>>
Aquí está la respuesta anterior con un poco de pagar, aunque todavía no es muy genérico o de fantasía ( 236 bytes ):

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

Una respuesta bastante aburrida, ya que simplemente generar el resultado sin demasiadas cosas elegantes es más corto en Java que un enfoque genérico.

Ungolfed y código de prueba:

Pruébalo aquí

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

Salida:

()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
Kevin Cruijssen
fuente
1

Qbasic, 175 bytes

?"()()()()()()":?"|\3.1415926|":?"|:\53589793|":?"\::\2384626|":?" \::\433832|":?"  \::\79502|":?"   \::\8841|":?"    \::\971|":?"     \::\69|":?"      \::\3|":?"       \__\|"
anónimo2
fuente
1

Lua, 152 bytes

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

Por más que lo intenté, no pude comprimir este pi.

Lua es demasiado detallado para hacerlo, tal vez un pi de mayor tamaño, pero no este.

Otra solución, 186 Bytes.

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..'       \\__\\|')

Molestamente, el pi de Lua no es lo suficientemente preciso como para llenar el pi. :(

Un taco
fuente
1

Javascript, 172 bytes

Pega en tu consola para correr.

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
fuente
Bienvenido a PPCG! Para que lo sepas, puedes formatear tu código con cuatro espacios (ver mi edición). Además, coloque la cantidad de bytes en su programa en la parte superior de su respuesta (por ejemplo Javascript: 100 bytes).
Qwerp-Derp
Parece tener errores de sintaxis extraños, ¿puedes solucionarlos?
programmer5000
1

JavaScript (ES6), 170 bytes 165 bytes

es un poco "engañado", ya que si se ejecuta en la consola, se mostrará el valor de retorno

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

Después de un poco de aprendizaje, la función se ve así (se debe llamar a la función con el parámetro con el valor 0):

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

Si desea llamar a la función 167 bytes:

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

ganador_unista
fuente
1: Necesita par de cierre adicional. 2: reemplazar "|\n"con |<newline>where <newline>es una nueva línea literal. 3: Agregar y=>al principio y no será trampa. 4: ¡Bienvenido al sitio!
programmer5000
1
@ programmer5000 gracias por su aporte, lo usé en mi último ajuste. :-D
winner_joiner
Ahorre 2 bytes eliminando la ()inclusión del vparámetro. Su salida parece tener un espacio extra frente a las líneas 2 y 3. Además, no necesita pasar 0como argumento, su función funcionará bien sin ella y tampoco está permitida por el desafío.
Shaggy
sí, gracias, antes tenía el valor predeterminado. :-D
winner_joiner
0

PHP, 142 bytes

Sneaky-sneaky :) phpsimplemente imprime todo sin intentar interpretarlos como código PHP si no ve ningún <?php ?>par.

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