Cuocere una fetta di Pi


82

Scrivi un programma o una funzione che stampa o stampa questo esatto testo (composto da 142 caratteri):

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

Il tuo programma non deve accettare input (tranne che nelle lingue in cui ciò è impossibile, come sed) e produrre il testo sopra (e solo il testo sopra) come output. Una nuova riga finale è accettabile.

Questo è , quindi vince la risposta più breve (in byte).


9
@RohanJhunjhunwala Per provare che questo può essere compresso, Luis Mendo l'ha fatto .
Erik the Outgolfer,

1
Lol, mi è stato smentito (e sono contento!) Molto impressionante
Rohan Jhunjhunwala

2
Hai freddo li hai fatti prendere un input intero N per produrre una sezione il cui numero ()in alto è N. Sarebbe molto complesso però.
user6245072,

5
Solo per questo, hai bisogno di 43 cifre decimali di π.
Erik the Outgolfer,

4
Così vicino al significato della vita ....
A. Mirabeau,

Risposte:


90

MATL , 70 68 67 byte

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

Provalo online!

Spiegazione

Che casino. Ma hey, c'è una convoluzione!

La spiegazione sarà più chiara se è possibile ispezionare il contenuto dello stack dopo una determinata istruzione . Per farlo, basta inserire X#0$%a quel punto. (Ciò significa: X# mostra i contenuti dello stack, 0$non visualizzare implicitamente nient'altro, %commenta il resto del codice). Ad esempio, vedi lo stack subito dopo la convoluzione .

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

14
Luis Mendo, questo è impressionante. Vorrei votare due volte se potessi. Ho pensato che sarebbe stata una sfida incomprimibile per il kolmogorov. Grazie per avermi dimostrato di sbagliarmi!
Rohan Jhunjhunwala,

3
@Rohan Grazie per le tue gentili parole!
Luis Mendo,

1
: D Nessun problema! : D
Rohan Jhunjhunwala,

3
+1 per quello :)che appare nel tuo codice.
Erik the Outgolfer,

2
@Neil Guarda il lato positivo della vita ...
Erik the Outgolfer,

37

Perl, 93 byte

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

Richiede l'opzione della riga di comando -l71Mbignum=bpi, conteggiata come 14. \32Dovrebbe essere sostituita da un carattere letterale 26.

Esempio di utilizzo

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

Perl, 111 byte

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

Versione con parametri. Richiede l'opzione della riga di comando -nMbignum=bpi, conteggiata come 12.

Esempio di utilizzo

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

25

JavaScript (ES6), 187 174 byte

Questo è più corto di 1 byte rispetto alla semplice visualizzazione del testo in chiaro.

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)


1
Non è un byte più corto di console.log ("") + 12 * 11 caratteri + 18 barre rovesciate + 10 interruzioni di riga?
Tito,

@Titus - Hai ragione. Ho dimenticato di contare la fuga della barra rovesciata. Grazie!
Arnauld,

18
Leggermente interessante, ma 2384626433832795028841971693 sembra essere il primo.
ElementW,

1
@ElementW - Divertente che tu l'abbia menzionato, perché ho controllato anche quello. :)
Arnauld,

Scrivere il numero come esadecimale e convertirlo in una stringa salverebbe eventuali byte?
Nic Hartley,

17

Python 2, 131 byte

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

Sforzo congiunto tra Sp3000 e Lynn. Anche il rame ha salvato un byte! Collegamento Ideone.


È elegante +1
ElPedro,

Dovresti essere in grado di salvare 1 byte rimuovendo le parentesi nel forloop.
Rame

16

/// , 129 127 byte

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

Provalo online!


-2 byte se lo fai /!/()()/!!!invece di ()()()()()()e sostituisci /#/|\n%%/con /#/|\n%/e regola il resto del codice per farlo funzionare con quello.
acrolith,

@daHugLenny Oh grazie, non sapevo che 4 * 3 fosse un candidato valido per la sostituzione. Per il tuo secondo suggerimento, penso che sarà più lungo.
Erik the Outgolfer,

@daHugLenny ^^ Posso confermare che il tuo secondo suggerimento è davvero più lungo.
Erik the Outgolfer,


@DestructibleWatermelon L'ho fatto intenzionalmente. Ci sono anche altri volti: -:, :-, :-e -__-.
Erik the Outgolfer,

12

Bash, 153 byte

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

9
Considerando quante altre risposte sono cadute nella trappola della produzione di codice più a lungo della stampa della torta letterale , penso che questa sia davvero una risposta intelligente. Inoltre, sono solo 153 byte dal mio conteggio.
Lynn,

3
@Lynn Tuttavia, sta semplicemente scaricando l'esempio sull'output senza tentare di giocare a golf, e quindi è scoraggiato. Almeno le altre risposte hanno fatto uno sforzo ...
Decadimento beta

È possibile rimuovere gli spazi prima e dopo il <<. E il tuo byte è di 153 byte.
TuxCrafting,

1
Non è echo '()()()()()()...\__\|'4 byte più breve?
Neil,

@Lynn Sono contento di non aver avuto quel problema; Il batch richiede 100 byte di sovraccarico per stampare semplicemente la torta.
Neil,

9

Lotto, 195 byte

@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^|

5

Turtlèd , 135 129 byte (non in competizione)

(l'interprete non è davvero un po ' buggèd (più:]) , ma non influisce su questo programma )

Ristrutturando e riscrivendo il mio programma, ho giocato a golf ... sei byte

E ora devo fare una nuova spiegazione ...

Tuttavia, potrebbero essere ancora più brevi


Almeno la migliore soluzione in questo lang non è solo scrivere nei dati grezzi ¯ \ _ (ツ) _ / ¯


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

Provalo online

Spiegazione

Onestamente, questo non descrive molto bene il programma attuale, ma dà suggerimenti sui comandi, quindi potresti capire un po 'meglio

#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 COMPLESSA: ANELLI NIDATI

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

Mentre la cella corrente non è spazio {sposta a sinistra, esegue il ciclo: (Mentre la cella non |, scrive il carattere corrente della variabile stringa (ricorda che pi?), Incrementa il puntatore della stringa, sposta a sinistra), esegui il ciclo: (mentre la cella non \, sposta a destra), sposta verso l'alto, a sinistra}


Perché non competere?
programmatore

non competere significa che è più recente della sfida
Limone distruttibile

5

Fourier, 196 190 byte

Avviso nuova funzione!

Codice

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

Spiegazione

Questo programma è la mia prima dimostrazione di funzioni in Fourier:

Le funzioni sono definite in questo modo:

|code goes here|f

La prima pipe avvia la dichiarazione di funzione. Quindi inserisci il codice tra i tubi. L'ultima pipe termina la dichiarazione di funzione. Infine, ilf è la variabile in cui è memorizzata la funzione. Questo può essere qualsiasi personaggio, purché non sia una funzione riservata.

Ad esempio, nel mio codice, una delle funzioni è:

|SaCaaSa|f

Dove la variabile Smemorizza il numero 92 e Cmemorizza il numero 58.

Quando viene chiamata, la funzione genera quanto segue:

\::\

Dal momento che è la cosa più ripetuta nella torta.

Allo stesso modo, per golfare l'output, ho usato un loop:

6(40a41ai^~i)

Che ripete il codice 40a41a6 volte. 40a41asulle proprie uscite:

()

Quindi ripetendo il codice sei volte output:

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

In tal modo producendo la crosta della torta.

Provalo su FourIDE!

Poiché non ho implementato le funzioni nell'interprete Python, questo programma non funzionerà su http://tryitonline.net


4

Pyth, 89 byte

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

Provalo online!

Sostituisci \xx(esadecimale) con il corrispondente carattere ASCII se copi / incolli il codice da questa risposta; contiene caratteri non stampabili nella stringa compressa che SE filtra.

Spiegazione

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

4

Gelatina , 83 byte

sicuramente ancora abbastanza golfabale

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

TryItOnline

Come?

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
Wow, questo è il programma Jelly più lungo che abbia mai visto: o
Decadimento beta

@BetaDecay senza dubbio può essere fatto in 11 byte ...
Jonathan Allan,

3

Python 2, 193 176 byte

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 risposta più breve e noiosa:

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

3
Sei consapevole che print r'''(the pie)'''è più breve di 38 byte? :)
Lynn,

+1 per il tuo secondo tentativo, ma l'utilizzo di virgolette singole rende più breve la visualizzazione. Il conteggio dei pixel è migliore :)
ElPedro

3

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

* Trovo che questo non sia originale e che tradisca

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

201 byte:

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

Sono sicuro che qui c'è qualcosa da giocare a golf

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

Grazie per la risposta! È possibile salvare almeno un byte rimuovendo lo spazio aggiuntivo in .Substring(j, i).
Rame

Questa è stata una svista dalla formattazione automatica in VS, ma ho comunque salvato un mucchio in un modo diverso =)
pinkfloydx33

Una funzione anonima che restituisce la torta alla lettera è> 25% più corta: ()=>@"(pie)"149 byte .
Lynn,

È anche noioso e sembra barare. Le regole dicono di stampare, non di tornare
pinkfloydx33

@ pinkfloydx33 La stampa e la restituzione sono entrambe consentite per impostazione predefinita in base al consenso della comunità.
mbomb007,

3

PowerShell , 105 byte

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

Provalo online!

Non sono sicuro di come non abbia mai risposto a questa sfida ... L'ho votata e molte altre risposte. Vabbè, meglio tardi che mai?

In questo modo sei parentesi bilanciate come stringa sulla pipeline, quindi una stringa letterale (salva due byte) delle due righe successive. Quindi, passiamo attraverso il resto dei numeri, ogni iterazione incrementa il numero di spazi preposti ( $i) concatenati \::<number>|. Infine, creiamo una stringa della punta della torta. Quelle stringhe sono tutte lasciate in cantiere e sono impliciteWrite-Output inserisce in una nuova riga.

Si tratta di 39 byte in meno rispetto alla semplice stampa della torta.


3

Carbone , 31 byte

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

Provalo online!

Forse ti starai chiedendo: cos'è questa stregoneria? Come puoi riempireUGPi ? Bene, Charcoal sta iniziando a ottenere il supporto di Wolfram Language, nella speranza che un giorno possa essere competitivo in più sfide!

Precedente, 71 byte

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

Provalo online!

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

Si noti che questo è diverso poiché il deverbosificatore comprime automaticamente le stringhe e non rimuove i comandi ridondanti.

Con stringhe compresse, 52 byte

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

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

Provalo online!


2

PHP, 170 byte

nessuna precisione arbritrale Pi in PHP? Il calcolo richiede molto più spazio di Copia e incolla. Non importa che l'ultima cifra qui sia tagliata, non arrotondata; ma a 64 bit Pi l'ultima cifra viene arrotondata per eccesso.

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

Corri con php -r '<code>'

ripartizione non commentata

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

Nell'output manca 1 spazio (che è possibile correggere modificandolo 13con a 14). E, per qualche bizzarro motivo, ti manca la parentesi di chiusura in alto. Apportare la modifica corregge l'output.
Ismael Miguel,

Le risposte PHP hanno bisogno di un <?phptag, altrimenti producono solo un output costante. Ciao PHP, mondo! in realtà dipende da questo. Tuttavia, parlando di output costante, una risposta PHP che contiene solo la torta letterale e nessun <?phptag potrebbe battere la tua di un grande margine ...
Lynn

@Lynn: PHP non ha bisogno del <?phptag quando lo esegui -r.
Tito,

2

Python 2, 183 171 byte

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

Non fa davvero nulla di intelligente. Costruisce solo una grande stringa e poi la stampa.

MODIFICARE

Ridotto a 171 dopo aver letto la risposta e l'apprendimento di @ Lynn. Scusami se è sbagliato (spudoratamente) rubarti alcuni byte senza che te lo suggerisca. Per favore, dimmi se è così e annullerò la modifica.

Produzione

python pi.pie.py

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

Sei consapevole che print r'''(the pie)'''è più breve di 28 byte? :)
Lynn,

@Lynn Non è barare? ;-)
ElPedro,

Non è un imbroglio, ma non molto interessante (e non abbiamo bisogno di quella risposta per ogni lingua, IMO. La risposta bash è sufficiente). Più come qualcosa che vorresti menzionare quando pubblichi una risposta come questa, per riconoscere che il tuo tentativo di golf è finito per essere una perdita. Forse vale comunque la pena pubblicare nel caso in cui qualcun altro veda un modo per prendere la tua idea sul golf e migliorarla, magari battendo l'approccio ingenuo.
Peter Cordes,

Prendo i tuoi commenti a bordo di @Peter. non stavo cercando di essere irrispettoso, quindi la faccina. Chiunque può semplicemente stampare una sfida di arte ASCII come questa. Sono abbastanza nuovo per questo e sono qui per imparare. Se significa qualcosa, ho inserito un commento e un +1 sulla risposta di Lynn quando ho visto che non si trattava solo di una dichiarazione stampata, ma ho affrontato il problema in un modo che ha totalmente superato i miei sforzi. Ho imparato ...
ElPedro,

Finché la tua risposta ha ancora un approccio diverso, va bene ricavare idee da altre risposte (nella stessa lingua o meno). L'unica cosa che non andrebbe bene è se la tua risposta finisse con lo stesso codice di Lynn. Di solito se vedi un piccolo miglioramento nella risposta di qualcun altro, lo suggeriresti in un commento. Ma se hai più idee nuove dopo aver visto la risposta di qualcun altro, puoi persino pubblicare la tua versione migliorata come nuova risposta. Non sono completamente sicuro dell'etichetta di questo, ma penso che vada bene finché la tua risposta è significativamente diversa.
Peter Cordes,

2

Rubino, 140 138 137 byte

La mia soluzione a questo problema in ruby, questa è la mia prima risposta di golf in codice: 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)}

Versione leggibile e spiegazione:

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

Niente di veramente intelligente, usando solo alcuni semplici loop :)

Produzione:

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

2
Benvenuti in PPCG! Bel primo post!
Rɪᴋᴇʀ

2

Stax , 63 byte

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

Esegui ed esegui il debug online!

Più breve della risposta MATL accettata. Sarebbe sicuramente più breve se più cifre fossero memorizzate come il pi costante in Stax.

(Cos'è quello Pi<0nel codice?)

Spiegazione

Usa l'equivalente ASCII per spiegare, che è

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

1

Java 7, 260 236 191 byte

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

. Sigh, semplicemente emettendo la torta è più breve, anche con tutti i backslash escape ..>>
Ecco la risposta precedente, con un po 'di permettersi, anche se ancora non molto generica o di fantasia ( 236 byte ):

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 risposta piuttosto noiosa, dal momento che produrre semplicemente il risultato senza troppe cose fantasiose è più breve in Java di un approccio generico.

Codice non testato e test:

Provalo qui.

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

Produzione:

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

1

Qbasic, 175 byte

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

1

Lua, 152 byte

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

Prova come potrei non riuscire a comprimere questo pi.

Lua è troppo prolissa per farlo, forse un pi di dimensioni maggiori, ma non questo.

Un'altra soluzione, 186 byte.

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

Purtroppo il pi di Lua non è abbastanza preciso da riempire anche il pi. :(


1

Javascript, 172 byte

Incolla nella tua console per l'esecuzione.

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)

Benvenuti in PPCG! Solo così sai, puoi formattare il tuo codice con quattro spazi (vedi la mia modifica). Inoltre, inserisci la quantità di byte nel tuo programma nella parte superiore della tua risposta (ad es Javascript: 100 bytes.).
Qwerp-Derp,

Sembra avere strani errori di sintassi, puoi sistemarli?
programmatore

1

JavaScript (ES6), 170 byte 165 byte

è un po '"ingannato", poiché se eseguito sulla console, verrà visualizzato il valore restituito

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

Dopo un po 'di teaking, la funzione è simile a questa (la funzione deve essere chiamata con il parametro con il valore 0):

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

Se si desidera chiamare la funzione 167 byte:

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


1: richiede una chiusura extra. 2: sostituisci "|\n"con |<newline>dov'è <newline>una newline letterale. 3: aggiungi y=>all'inizio e non sarà un imbroglio. 4: Benvenuti nel sito!
programmatore

1
@ programmer5000 grazie per il tuo contributo, l'ho usato sul mio ultimo tweak. :-D
winner_joiner

Salvare 2 byte rimuovendo ()il vparametro racchiuso . L'output sembra avere uno spazio aggiuntivo davanti alla 2a e 3a riga. Inoltre, non è necessario passare 0come argomento, la tua funzione funzionerà bene senza di essa e non è nemmeno consentita dalla sfida.
Shaggy,

si grazie, avevo prima il valore predefinito. :-D
winner_joiner

0

PHP, 142 byte

Sneaky-subdolo :) phpstampa tutto senza cercare di interpretarli come codice PHP se non vede alcuna <?php ?>coppia.

()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.