Asse uma fatia de Pi


82

Escreva um programa ou função que imprima ou envie esse texto exato (composto por 142 caracteres):

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

Seu programa não deve receber nenhuma entrada (exceto em idiomas onde isso é impossível, como sed) e produzir o texto acima (e somente o texto acima) como saída. Uma nova linha à direita é aceitável.

Isso é , então a resposta mais curta (em bytes) vence.


9
@RohanJhunjhunwala Para provar que isso pode ser compactado, Luis Mendo fez isso .
Erik the Outgolfer

1
Lol, eu tenho provado que estou errado (e estou feliz!) Muito impressionante
Rohan Jhunjhunwala

2
Você fez com que eles usassem uma entrada inteira N para gerar uma fatia cujo número ()no topo é N. Seria muito complexo.
User6245072

5
Só para você saber, você precisa de 43 casas decimais de π.
Erik the Outgolfer

4
Tão perto do significado da vida ....
A. Mirabeau

Respostas:


90

MATL , 70 68 67 bytes

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

Experimente online!

Explicação

Que bagunça. Mas ei, há uma convolução!

A explicação será mais clara se você puder inspecionar o conteúdo da pilha após uma determinada instrução . Para fazer isso, basta inserir X#0$%nesse ponto. (Isso significa: X# mostrar o conteúdo da pilha, 0$não exibir implicitamente mais nada, %comentar o restante do código). Por exemplo, veja a pilha logo após a convolução .

'()'       % 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, isso é impressionante. Eu votaria duas vezes se pudesse. Eu pensei que este seria um desafio incompreensível para Kolmogorov. Obrigado por me provar que estou errado!
Rohan Jhunjhunwala

3
@ Rohan Obrigado por suas amáveis ​​palavras!
Luis Mendo

1
: D Não tem problema! : D
Rohan Jhunjhunwala

3
+1 para o :)que aparece no seu código.
Erik the Outgolfer

2
@Neil Veja o lado bom da vida ...
Erik o Outgolfer

37

Perl, 93 bytes

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

Requer a opção de linha de comando -l71Mbignum=bpi, contada como 14. Ela \32deve ser substituída por um caractere literal 26.

Uso da amostra

$ 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

Versão parametrizada. Requer a opção de linha de comando -nMbignum=bpi, contada como 12.

Uso da amostra

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

Este é 1 byte mais curto do que apenas exibir o texto sem formatação.

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
Não é um byte menor que console.log ("") + 12 * 11 caracteres + 18 barras invertidas + 10 quebras de linha?
Titus

@ Titus - Você está certo. Eu esqueci de contar a barra invertida escapando. Obrigado!
Arnauld

18
Levemente interessante, mas 2384626433832795028841971693 passa a ser o principal.
ElementW 17/09/16

1
@ElementW - Engraçado que você mencionou, porque eu verifiquei isso também. :)
Arnauld

Escrever o número como hexadecimal e convertê-lo em uma string salvaria alguns 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))

Esforço conjunto entre Sp3000 e Lynn. O cobre também salvou um byte! Link Ideone.


Isso é elegante +1
ElPedro

Você poderá salvar 1 byte removendo os colchetes no forloop.
Copper

16

/// , 129 127 bytes

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

Experimente online!


Bytes -2 se o fizer /!/()()/!!!, em vez de ()()()()()()e substituir /#/|\n%%/com /#/|\n%/e ajustar o resto do código para que ele funcione com isso.
acrolith 17/09/16

@daHugLenny Oh, obrigado, eu não sabia que 4 * 3 era um candidato válido para substituição. Para sua segunda sugestão, acho que vai demorar mais.
Erik the Outgolfer

@daHugLenny ^^ Posso confirmar que sua segunda sugestão é realmente mais longa.
Erik the Outgolfer


@DestructibleWatermelon Fiz isso intencionalmente. Há também outras faces: -:, :-, :-e -__-.
Erik the Outgolfer

12

Bash, 153 bytes

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

9
Considerando quantas das outras respostas caíram na armadilha de produzir código por mais tempo do que imprimir a torta literal , acho que essa é realmente uma resposta inteligente. Além disso, são apenas 153 bytes pela minha contagem.
Lynn

3
@ Lynn No entanto, ele está apenas despejando o exemplo na saída sem nenhuma tentativa de jogar golfe, e isso é desencorajado. Pelo menos as outras respostas fizeram um esforço ...
Decay Beta Beta

Você pode remover os espaços antes e depois do <<. E seu número de bytes é de 153 bytes.
TuxCrafting

1
Não são echo '()()()()()()...\__\|'4 bytes mais curtos?
Neil

@ Lynn Estou feliz por não ter esse problema; O lote requer 100 bytes de sobrecarga para simplesmente imprimir a torta.
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^|

5

Turtlèd , 135 129 bytes (não competindo)

(o intérprete não é realmente um pouco problemático (mais:]) , mas não afeta este programa )

Ao reestruturar e reescrever meu programa, joguei golfe ... seis bytes

E agora eu tenho que fazer uma nova explicação ...

Ainda poderia haver probs mais curtos


Pelo menos a melhor solução nesse idioma não é apenas escrever nos dados brutos ¯ \ _ (ツ) _ / ¯


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

Experimente online

Explicação

Honestamente, isso não descreve muito bem o programa atual, mas fornece dicas sobre os comandos, para que você possa entender um pouco melhor

#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

COISA COMPLEXA: LOOPS NESTED

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

Enquanto a célula atual não estiver no espaço {mova para a esquerda, execute o loop: (enquanto a célula não |, escreva o caractere atual da variável string (lembre-se que pi?), Aumente o ponteiro da string, mova para a esquerda), execute o loop: (enquanto a célula não \, mova para a direita), mova para cima, para a esquerda}


Por que não competir?
programmer5000

não significa competindo é mais recente do que o desafio
Destrutível Lemon

5

Fourier, 196 190 bytes

Alerta de novo recurso!

Código

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

Explicação

Este programa é minha primeira demonstração de funções em Fourier:

As funções são definidas da seguinte forma:

|code goes here|f

O primeiro tubo inicia a declaração da função. Você coloca o código entre os canos. O último canal termina a declaração da função. Finalmente, fé a variável na qual a função está armazenada. Pode ser qualquer caractere, desde que não seja uma função reservada.

Por exemplo, no meu código, uma das funções s é:

|SaCaaSa|f

Onde a variável Sarmazena o número 92 e Co número 58.

Quando chamada, a função gera o seguinte:

\::\

Uma vez que é a coisa mais repetida na torta.

Da mesma forma, para reduzir a saída, usei um loop:

6(40a41ai^~i)

O qual repete o código 40a41a6 vezes. 40a41aem suas próprias saídas:

()

Então, repetindo o código seis vezes as saídas:

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

Produzindo assim a crosta da torta.

Experimente no FourIDE!

Como eu não implementei funções no interpretador Python, este programa não funcionará em http://tryitonline.net


4

Pitão, 89 bytes

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

Experimente online!

Substitua \xx(hexadecimal) pelo caractere ASCII correspondente se você copiar / colar o código desta resposta; ele contém caracteres não imprimíveis na sequência compactada que o SE filtra.

Explicação

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 bytes

certamente ainda bastante golfabale

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

TryItOnline

Quão?

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
Uau, esse é o programa mais longo de Jelly que eu já vi: o
Beta Decay

@BetaDecay sem dúvida, isso pode ser feito em 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+"\__\|"

Ou uma resposta mais curta e mais chata:

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

3
Você sabe que print r'''(the pie)'''é 38 bytes mais curto? :)
Lynn

+1 para o seu segundo esforço, mas o uso de aspas simples diminui a aparência. Contagem de pixels é melhor :)
ElPedro

3

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

* Acho que isso não é original e trapaça

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:

Tenho certeza de que há algo para ser jogado aqui

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

Obrigado pela resposta! Você pode salvar pelo menos um byte removendo o espaço extra .Substring(j, i).
Copper

Isso foi um descuido de auto-formatação no VS, mas salvou um monte uma maneira diferente de qualquer maneira =)
pinkfloydx33

Uma função anônima que retorna a torta literalmente é> 25% menor: ()=>@"(pie)"são 149 bytes .
Lynn

Também é chato e parece trapaça. Regras dizem para imprimir, não voltar
pinkfloydx33

@ pinkfloydx33 A impressão e o retorno são permitidos por padrão, de acordo com o consenso da comunidade.
mbomb007

3

PowerShell , 105 bytes

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

Experimente online!

Não tenho certeza de como nunca respondi a esse desafio ... Eu votei nele e em várias outras respostas. Bem, antes tarde do que nunca?

Isso coloca seis parênteses balanceados como uma string no pipeline, depois uma string literal (salva dois bytes) das próximas duas linhas. Em seguida, percorremos o restante dos números, cada iteração incrementando o número de espaços prefixados ( $i) concatenados com \::<number>|. Por fim, criamos uma sequência da ponta da torta. Essas strings são todas deixadas no pipeline, e um implícito Write-Outputadere uma nova linha entre elas.

Isso é 39 bytes mais curto do que apenas imprimir a pizza.


3

Carvão , 31 bytes

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

Experimente online!

Você pode estar se perguntando: o que é essa feitiçaria? Como você pode preencher comUGPi ? Bem, a Charcoal está começando a receber o suporte da Wolfram Language, na esperança de que um dia possa ser competitivo em mais desafios!

Anterior, 71 bytes

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

Experimente online!

Verbose

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

Observe que isso é diferente, pois o deverbosifier compacta automaticamente as seqüências de caracteres e não remove comandos redundantes.

Com cadeias compactadas, 52 bytes

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

saída 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..

Experimente online!


2

PHP, 170 bytes

nenhuma precisão arbitrária Pi em PHP? O cálculo ocupa muito mais espaço do que Copiar e Colar. Não importa que o último dígito aqui seja cortado, não arredondado; mas no Pi de 64 bits, o último dígito é arredondado.

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

Correr com php -r '<code>'

desagregação não comentada

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

Falta 1 espaço na saída (que você pode corrigir alterando isso 13com a 14). E, por algum motivo bizarro, você está perdendo o parêntese de fechamento na parte superior. Fazer a alteração corrige a saída.
Ismael Miguel

As respostas PHP precisam de uma <?phptag, caso contrário, elas produzem saída constante. Olá, mundo! na verdade depende disso. No entanto, falando de saída constante, uma resposta PHP que contém apenas o bolo literal e sem <?phptag em tudo iria bater seu por uma margem grande ...
Lynn

@ Lynn: PHP não precisa da <?phptag quando você a executa -r.
Titus

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 não faz nada inteligente. Apenas cria uma corda grande e depois a imprime.

EDITAR

Reduzido para 171 depois de ler a resposta e o aprendizado de @ Lynn. Desculpe se é errado (descaradamente) roubar alguns bytes de você sem você sugerir. Por favor, diga-me se sim e reverteremos a alteração.

Resultado

python pi.pie.py

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

Você sabe que print r'''(the pie)'''28 bytes são mais curtos? :)
Lynn

@ Lynn Isso não é trapaça? ;-)
ElPedro 18/09/16

Não é trapaça, apenas não é muito interessante (e não precisamos dessa resposta para todos os idiomas, IMO. A resposta do bash é suficiente). Mais como algo que você gostaria de mencionar ao postar uma resposta como essa, para reconhecer que sua tentativa de golfe acabou sendo uma perda. Talvez ainda valha a pena postar, caso alguém veja uma maneira de aproveitar e melhorar sua ideia de golfe, talvez superando a abordagem ingênua.
Peter Cordes

Aceito seus comentários a bordo de Peter. Eu não estava tentando ser desrespeitoso, portanto, o smiley. Qualquer um pode simplesmente imprimir um desafio artístico ASCII como este. Eu sou muito novo nisso e estou aqui para aprender. Se isso significa alguma coisa, eu coloquei um comentário e um +1 na resposta de Lynn quando vi que não era apenas uma declaração impressa, mas resolvi o problema de uma maneira que superou totalmente meu esforço. Eu aprendi ...
ElPedro

Desde que sua resposta ainda tenha uma abordagem diferente, é bom obter idéias de outras respostas (no mesmo idioma ou não). A única coisa que não seria legal é se sua resposta terminasse exatamente com o mesmo código que o de Lynn. Normalmente, se você vir uma pequena melhoria na resposta de outra pessoa, sugeriria isso em um comentário. Mas se você tiver várias idéias novas depois de ver a resposta de outra pessoa, poderá postar sua versão aprimorada como uma nova resposta. Não tenho muita certeza sobre a etiqueta disso, mas acho que está tudo bem, desde que sua resposta seja significativamente diferente.
Peter Cordes

2

Ruby, 140 138 137 bytes

Minha solução para este problema em ruby, esta é minha primeira resposta de código de golfe: 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)}

Versão legível e explicação:

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 muito inteligente, basta usar alguns loops simples :)

Resultado:

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

2
Bem-vindo ao PPCG! Bom primeiro post!
Rɪᴋᴇʀ

2

Stax , 63 bytes

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

Execute e depure online!

Menor que a resposta MATL aceita. Definitivamente seria mais curto se mais dígitos fossem armazenados como o pi constante no Stax.

(O que é isso Pi<0no código?)

Explicação

Usa o equivalente ASCII para explicar, que é

.()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 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, simplesmente produzir a torta é mais curto, mesmo com todas as barras invertidas escaparam ..>>
Aqui está a resposta anterior com um pouquinho de pagar, embora ainda não muito genérico ou fantasia ( 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)+"\\__\\|";}

Uma resposta bastante chata, já que simplesmente produzir o resultado sem muitas coisas sofisticadas é mais curto em Java do que uma abordagem genérica.

Ungolfed & código de teste:

Experimente aqui.

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

Resultado:

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

1

Qbasic, 175 bytes

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

1

Lua, 152 bytes

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

Por mais que eu tentasse, não consegui compactar esse pi.

Lua é muito detalhada para fazer isso, talvez um pi de tamanho maior, mas não este.

Outra solução, 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..'       \\__\\|')

Irritantemente, o pi de Lua não é preciso o suficiente para preenchê-lo. :(


1

Javascript, 172 bytes

Cole no seu console para executar.

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)

Bem-vindo ao PPCG! Só para você saber, você pode formatar seu código com quatro espaços (veja minha edição). Além disso, coloque a quantidade de bytes no seu programa na parte superior da sua resposta (por exemplo Javascript: 100 bytes).
Qwerp-Derp

Parece ter erros de sintaxe estranhos, você pode corrigi-los?
programmer5000

1

JavaScript (ES6), 170 bytes 165 bytes

é um pouco "enganado", pois, se executado no console, o valor retornado será exibido

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

Após algumas tentativas, a função fica assim (a função deve ser chamada com o parâmetro com o valor 0):

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

Se você deseja chamar a função 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));


1: Precisa de parênteses de fechamento extra. 2: substitua "|\n"por |<newline>onde <newline>está uma nova linha literal. 3: Adicione y=>ao começo e não será trapaça. 4: Bem-vindo ao site!
programmer5000

1
@ programmer5000 obrigado pela sua contribuição, usei-o no meu último ajuste. :-D
winner_joiner

Salve 2 bytes removendo ()o vparâmetro que acompanha o item. Sua saída parece ter um espaço extra na frente da segunda e terceira linhas. Além disso, você não precisa passar 0como argumento, sua função funcionará bem sem ela e também não é permitida pelo desafio.
Shaggy

sim obrigado, eu tinha antes do valor padrão. :-D
winner_joiner

0

PHP, 142 bytes

Sneaky-sneaky :) phpapenas imprime tudo sem tentar interpretá-los como código PHP se não houver <?php ?>pares.

()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.