Cuire une tranche de Pi

82

Ecrivez un programme ou une fonction qui imprime ou affiche ce texte exact (composé de 142 caractères):

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

Votre programme ne doit prendre aucune entrée (sauf dans les langues où cela est impossible, tel que sed) et produire le texte ci-dessus (et uniquement le texte ci-dessus) en sortie. Un retour à la ligne est acceptable.

C'est du , donc la réponse la plus courte (en octets) est gagnante.

Cuivre
la source
9
@RohanJhunjhunwala Pour prouver que cela peut être compressé, Luis Mendo l'a fait .
Erik the Outgolfer
1
Lol, je me suis trompé (et j'en suis heureux!) Très impressionnant
Rohan Jhunjhunwala
2
Vous leur avez fait prendre une entrée entière N pour produire une tranche dont le nombre ()au sommet est N. Cela serait très complexe cependant.
user6245072
5
Juste pour que vous sachiez, vous avez besoin de 43 décimales de π.
Erik the Outgolfer
4
Si proche du sens de la vie ....
A. Mirabeau

Réponses:

90

MATL , 70 68 67 octets

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

Essayez-le en ligne!

Explication

Quel bordel. Mais bon, il y a une convolution!

L'explication sera plus claire si vous pouvez inspecter le contenu de la pile après une instruction donnée . Pour le faire, insérez simplement X#0$%à ce point. (Cela signifie: X# afficher le contenu de la pile, 0$ne rien afficher implicitement, %commenter le reste du code). Par exemple, voyez la pile juste après la convolution .

'()'       % 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
la source
14
Luis Mendo, c'est impressionnant. Je voterais deux fois si je pouvais. Je pensais que ce serait un défi incompressible kolmogorov. Merci de me prouver le contraire!
Rohan Jhunjhunwala
3
@ Rohan Merci pour vos bons mots!
Luis Mendo
1
: D Pas de problème! : D
Rohan Jhunjhunwala
3
+1 pour le :)qui apparaît dans votre code.
Erik the Outgolfer
2
@Neil Voyez le bon côté de la vie ...
Erik the Outgolfer, le
37

Perl, 93 octets

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

Requiert l'option de ligne de commande -l71Mbignum=bpi, comptabilisée comme 14. Cela \32devrait être remplacé par un caractère littéral 26.

Exemple d'utilisation

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

Perl, 111 octets

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

Version paramétrée. Requiert l’option de ligne de commande ( -nMbignum=bpi12).

Exemple d'utilisation

$ 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
la source
25

JavaScript (ES6), 187 174 octets

C'est un octet plus court que le simple affichage du texte brut.

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
la source
1
N'est-ce pas un octet plus court que console.log ("") + 12 * 11 caractères + 18 barres obliques inverses + 10 coupures de ligne?
Titus
@ Titus - Vous avez raison. J'ai oublié de compter la barre oblique inverse s'échappant Merci!
Arnauld
18
Légèrement intéressant, mais 2384626433832795028841971693 se trouve être primordial.
ElementW
1
@ElementW - C'est drôle que vous en ayez parlé, car j'ai aussi vérifié cela. :)
Arnauld
L'écriture du nombre au format hexadécimal et sa conversion en chaîne permettraient-elles de sauvegarder des octets?
Nic Hartley le
17

Python 2, 131 octets

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

Effort conjoint entre Sp3000 et Lynn. Le cuivre a également sauvegardé un octet! Lien Ideone.

Lynn
la source
C'est élégant +1
ElPedro
Vous devriez pouvoir sauvegarder 1 octet en supprimant les crochets dans la forboucle.
Cuivre
16

/// , 129 127 octets

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

Essayez-le en ligne!

Erik l'Outgolfeur
la source
-2 octets si vous faites /!/()()/!!!au lieu de ()()()()()()et remplacez /#/|\n%%/par /#/|\n%/et ajustez le reste du code pour le faire fonctionner avec ça.
acrolithe
@ daHugLenny Oh merci, je ne savais pas que 4 * 3 était un candidat valide pour le remplacement. Pour votre deuxième suggestion, je pense que ce sera plus long.
Erik the Outgolfer
@daHugLenny ^^ Je peux confirmer que votre deuxième suggestion est effectivement plus longue.
Erik the Outgolfer
@ DestructibleWatermelon je l'ai fait intentionnellement. Il y a aussi d' autres visages: -:, :-, :-et -__-.
Erik l'Outgolfer
12

Bash, 153 octets

cat << _
()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
_
Chris
la source
9
Compte tenu du nombre d’autres réponses qui sont tombées dans le piège de produire du code plus longtemps que d’imprimer le gâteau littéral , je pense que c’est une réponse intelligente. En outre, ce n'est que 153 octets par mon compte.
Lynn
3
@ Lynn Cependant, il ne fait que vider l'exemple de la sortie sans tenter de jouer au golf et est donc découragé. Au moins, les autres réponses ont fait un effort ...
Beta Decay
Vous pouvez supprimer les espaces avant et après le <<. Et votre décompte est de 153 octets.
TuxCrafting
1
echo '()()()()()()...\__\|'4 octets ne sont-ils pas plus courts?
Neil
@ Lynn Je suis content de ne pas avoir ce problème. Le traitement par lot nécessite 100 octets d’impression pour imprimer simplement la tarte.
Neil
9

Lot, 195 octets

@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
la source
5

Tourlèd , 135 129 octets (non en compétition)

(l'interprète n'est pas vraiment légèrement dérangé (plus:]) , mais cela n'affecte pas ce programme )

En restructurant et en réécrivant mon programme, j'ai joué au golf ... six octets

Et maintenant je dois faire une nouvelle explication ...

Peut-être encore des probs plus courts


Au moins la meilleure solution dans cette langue ne consiste pas simplement à écrire dans les données brutes ¯ \ _ () _ / ¯


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

Essayez-le en ligne

Explication

Honnêtement, cela ne décrit pas très bien le programme lui-même, mais donne des indications sur les commandes afin que vous puissiez comprendre un peu mieux.

#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

COMPLEXE: BOUCLES NUES

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

Alors que la cellule actuelle n’est pas un espace {déplacer à gauche, exécuter la boucle: (Alors que cellule pas |, écrire le caractère actuel de la variable chaîne (rappelez-vous que pi?), Incrémenter le pointeur de la chaîne, déplacer à gauche), exécuter la boucle: (lorsque la cellule n’est pas \, déplacer à droite), déplacer vers le haut, à gauche}

Citron destructible
la source
Pourquoi ne pas concurrencer?
programmer5000 le
pas en compétition signifie qu'il est plus récent que le défi
Lemon destructible
5

Fourier, 196 190 octets

Nouvelle fonctionnalité d'alerte!

Code

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

Explication

Ce programme est ma première démonstration de fonctions à Fourier:

Les fonctions sont définies comme suit:

|code goes here|f

Le premier canal lance la déclaration de fonction. Vous mettez ensuite le code entre les tuyaux. Le dernier canal termine la déclaration de fonction. Enfin, le fest la variable dans laquelle la fonction est stockée. Cela peut être n'importe quel caractère, tant que ce n'est pas une fonction réservée.

Par exemple, dans mon code, l’une des fonctions s est:

|SaCaaSa|f

Où la variable Sstocke le nombre 92 et Cstocke le nombre 58.

Lorsqu'elle est appelée, la fonction génère les éléments suivants:

\::\

Puisque c'est la chose la plus répétée dans la tarte.

De même, pour jouer en sortie, j'ai utilisé une boucle:

6(40a41ai^~i)

Ce qui répète le code 40a41a6 fois. 40a41asur ses propres sorties:

()

Donc, répéter le code six fois génère:

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

Sortant ainsi la croûte de la tarte.

Essayez-le sur FourIDE!

Comme je n'ai pas implémenté de fonctions dans l'interpréteur Python, ce programme ne fonctionnera pas sur http://tryitonline.net.

Beta Decay
la source
4

Pyth, 89 octets

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

Essayez-le en ligne!

Remplacez \xx(hexadécimal) par le caractère ASCII correspondant si vous copiez / collez le code de cette réponse. il contient des caractères non imprimables dans la chaîne compactée que SE filtre.

Explication

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
nom_insertion_ici
la source
4

Gelée , 83 octets

sûrement encore assez golfabale

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

TryItOnline

Comment?

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
la source
2
Wow, c'est le plus long programme de gelée que j'ai jamais vu: o
Beta Decay
@BetaDecay sans doute, cela peut être fait en 11 octets ...
Jonathan Allan
3

Python 2, 193 176 octets

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 une réponse plus courte et plus ennuyeuse:

print r"""()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|"""
acrolithe
la source
3
Savez-vous qu'il print r'''(the pie)'''est plus court de 38 octets? :)
Lynn
+1 pour votre deuxième effort, mais utiliser des guillemets simples le rend plus court à regarder. Le nombre de pixels est meilleur :)
ElPedro
3

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

* Je trouve que ce n'est pas original et triche

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

201 octets:

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

Je suis sûr qu'il y a quelque chose à jouer au golf ici

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
la source
Merci d'avoir répondu! Vous pouvez économiser au moins un octet en supprimant l’espace supplémentaire dans .Substring(j, i).
Cuivre
C’était un oubli de la mise en forme automatique dans VS, mais j’en ai sauvé de toute façon une
bosse
Une fonction anonyme renvoyant textuellement la tarte est> 25% plus courte: ()=>@"(pie)"149 octets .
Lynn
C'est aussi ennuyeux et donne l'impression de tricher. Les règles disent d'imprimer, pas de revenir
pinkfloydx33
@ pinkfloydx33 L'impression et le renvoi sont tous deux autorisés par défaut, selon le consensus de la communauté.
mbomb007
3

PowerShell , 105 octets

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

Essayez-le en ligne!

Je ne sais pas comment je n'ai jamais répondu à ce défi ... Je l'ai voté et plusieurs des autres réponses. Oh bien, mieux vaut tard que jamais?

Cela place six parens équilibrés en tant que chaîne sur le pipeline, puis une chaîne littérale (enregistre deux octets) des deux lignes suivantes. Ensuite, nous parcourons le reste des nombres, chaque itération incrémentant le nombre d'espaces ajoutés ( $i) au début de la concaténation \::<number>|. Enfin, nous créons une chaîne de la pointe de la tarte. Ces chaînes sont toutes laissées sur le pipeline, et un implicite Write-Outputcolle une nouvelle ligne entre elles.

C’est 39 octets de moins que la simple impression du graphique.

AdmBorkBork
la source
3

Charbon de bois , 31 octets

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

Essayez-le en ligne!

Vous vous demandez peut-être: quelle est cette sorcellerie? Comment pouvez-vous remplir avec UGPi? Eh bien, Charcoal commence à obtenir le soutien de Wolfram Language, dans l’espoir qu’il puisse un jour être compétitif face à plus de défis!

Précédent, 71 octets

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

Essayez-le en ligne!

Verbeux

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

Notez que ceci est différent car le déverbosifiant compresse automatiquement les chaînes et ne supprime pas les commandes redondantes.

Avec des chaînes compressées, 52 octets

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

xxd sortie

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

Essayez-le en ligne!

ASCII seulement
la source
2

PHP, 170 octets

pas de précision arbitraire Pi en PHP? Le calcul prend beaucoup plus de place que le copier-coller. Peu importe que le dernier chiffre soit coupé et non arrondi; mais en 64 bits Pi, le dernier chiffre est arrondi.

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

Courir avec php -r '<code>'

ventilation non commentée

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
la source
Il manque 1 espace dans la sortie (que vous pouvez corriger en le changeant 13avec a 14). Et, pour une raison étrange, il vous manque la parenthèse de fermeture en haut. Faire le changement corrige la sortie.
Ismael Miguel
Les réponses PHP nécessitent un <?phptag, sinon elles ne produisent que des résultats constants. Bonjour PHP, Monde! en fait dépend de cela. Cependant, en parlant de sortie constante, une réponse PHP qui ne contiendrait que le gâteau et aucune <?phpbalise du tout l'emporterait de loin sur la vôtre…
Lynn
@ Lynn: PHP n'a pas besoin de la <?phpbalise lorsque vous l'exécutez -r.
Titus
2

Python 2, 183 171 octets

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

Ne fait vraiment rien d'intelligent. Il suffit de construire une grosse chaîne puis de l’imprimer.

MODIFIER

Réduit à 171 après avoir lu la réponse et l'apprentissage de @ Lynn. Désolé s'il est faux de voler (sans vergogne) des octets sans que vous le suggériez. S'il vous plaît dites-moi si oui et je vais annuler le changement.

Sortie

python pi.pie.py

()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
ElPedro
la source
Savez-vous que print r'''(the pie)'''28 octets sont plus courts? :)
Lynn
@ Lynn Est-ce pas tricher? ;-)
ElPedro
Ce n'est pas de la triche, mais pas très intéressant (et nous n'avons pas besoin de cette réponse pour toutes les langues, IMO. La réponse est suffisante). C’est plutôt quelque chose que vous voudriez mentionner lorsque vous publiez une réponse comme celle-ci: reconnaître que votre tentative de jouer au golf a été une perte. Peut-être vaut-il la peine de poster au cas où quelqu'un verrait un moyen de prendre votre idée de golf et de l'améliorer, en battant peut-être l'approche naïve.
Peter Cordes le
Je prends vos commentaires à bord de Peter. Je n'essayais pas d'être irrespectueux d'où le smiley. N'importe qui peut simplement imprimer un défi artistique ASCII comme celui-ci. Je suis assez nouveau pour cela et je suis ici pour apprendre. Si cela signifiait quelque chose, je mettais un commentaire et un +1 sur la réponse de Lynn lorsque je vis qu'il ne s'agissait pas simplement d'une déclaration imprimée, mais que le problème était traité d'une manière qui surpassait totalement mes efforts. J'ai appris ...
ElPedro le
Tant que votre réponse a toujours une approche différente, il est bon de tirer des idées d'autres réponses (dans la même langue ou non). La seule chose qui n'irait pas, c'est si votre réponse se retrouvait avec exactement le même code que celui de Lynn. Habituellement, si vous constatez une légère amélioration par rapport à la réponse de quelqu'un d'autre, vous suggéreriez cela dans un commentaire. Mais si vous avez plusieurs nouvelles idées après avoir vu la réponse de quelqu'un d'autre, vous pouvez même publier votre version améliorée en tant que nouvelle réponse. Je ne suis pas tout à fait sûr de l'étiquette, mais je pense que ça va tant que votre réponse est très différente.
Peter Cordes
2

Ruby, 140 138 137 octets

Ma solution à ce problème en rubis, c’est ma première réponse au code 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)}

Version lisible et explication:

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

Rien de bien malin, rien que de simples boucles :)

Sortie:

()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
Linus
la source
2
Bienvenue chez PPCG! Nice premier post!
Rɪᴋᴇʀ
2

Stax , 63 octets

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

Exécuter et déboguer en ligne!

Plus court que la réponse MATL acceptée. Ce serait certainement plus court si plus de chiffres étaient stockés comme pi constant dans Stax.

(Qu'est-ce que c'est Pi<0dans le code?)

Explication

Utilise l’équivalent ASCII pour expliquer, qui est

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

Java 7, 260 236 191 octets

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

. Soupir, fournir en sortie simplement la tarte est plus courte, même avec toutes les échappées antislashs ..>>
Voici la réponse précédente avec un petit peu de moyens, mais toujours pas très générique ou de fantaisie ( 236 octets ):

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

Une réponse plutôt ennuyeuse, car la sortie du résultat sans trop de fantaisie est plus courte en Java qu'une approche générique.

Ungolfed & code de test:

Essayez ici.

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

Sortie:

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

Qbasic, 175 octets

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

Lua, 152 octets

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

Essayez comme je pourrais je ne pourrais pas compresser ce pi.

Lua est trop verbeuse pour le faire, peut-être un pi de plus grande taille, mais pas celui-ci.

Une autre solution, 186 octets.

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

Ennuis, le pi de Lua n'est pas assez précis pour même le remplir. :(

ATaco
la source
1

Javascript, 172 octets

Collez dans votre console pour exécuter.

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
la source
Bienvenue chez PPCG! Juste pour que vous sachiez, vous pouvez formater votre code avec quatre espaces (voir mon édition). En outre, mettez la quantité d'octets de votre programme en haut de votre réponse (par exemple Javascript: 100 bytes).
clismique
Vous semblez avoir des erreurs de syntaxe étranges, pouvez-vous les corriger?
programmer5000 le
1

JavaScript (ES6), 170 octets 165 octets

est un peu "triché", car s'il était exécuté sur la console, la valeur de retour serait affichée

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

Après un peu de teck, la fonction ressemble à ceci (la fonction doit être appelée avec un paramètre avec la valeur 0):

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

Si vous voulez appeler la fonction 167 octets:

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
la source
1: Nécessite un paren de fermeture supplémentaire. 2: remplacer "|\n"par |<newline><newline>est un retour à la ligne littéral. 3: Ajoutez y=>au début et il ne sera pas tricher. 4: Bienvenue sur le site!
programmer5000 le
1
@ programmer5000 merci pour votre contribution, je l'ai utilisé dans mon dernier tweak. :-D
winner_joiner
Économisez 2 octets en supprimant ()le vparamètre englobant . Votre sortie semble avoir un espace supplémentaire devant les 2e et 3e lignes. En outre, vous n'avez pas besoin de passer 0pour un argument, votre fonction fonctionnera correctement sans cela et le défi ne le permet pas non plus.
Shaggy
oui merci, j'avais avant valeur par défaut. :-D
winner_joiner
0

PHP, 142 octets

Sneaky-sneaky :) affiche phpsimplement tout sans essayer de les interpréter en tant que code PHP s'il ne voit aucune <?php ?>paire.

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