Upiec kawałek Pi

82

Napisz program lub funkcję, która drukuje lub wyświetla ten dokładny tekst (składający się ze 142 znaków):

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

Twój program nie może pobierać żadnych danych (z wyjątkiem języków, w których jest to niemożliwe, np. sed) I generować powyższy tekst (i tylko powyższy tekst) jako wynik. Końcowy znak nowej linii jest dopuszczalny.

To jest , więc wygrywa najkrótsza odpowiedź (w bajtach).

Miedź
źródło
9
@RohanJhunjhunwala Aby udowodnić, że można to skompresować, Luis Mendo to zrobił .
Erik the Outgolfer,
1
Lol, udowodniono mi, że się mylę (i cieszę się!) Bardzo imponujące
Rohan Jhunjhunwala,
2
Przeziębiłeś się, aby przyjęli liczbę całkowitą N, aby uzyskać wycinek, którego liczba ()na górze to N. To byłoby bardzo skomplikowane.
user6245072 17.09.16
5
Właśnie dlatego wiesz, że potrzebujesz 43 miejsc po przecinku π.
Erik the Outgolfer,
4
Tak blisko sensu życia ...
A. Mirabeau,

Odpowiedzi:

90

MATL , 70 68 67 bajtów

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

Wypróbuj online!

Wyjaśnienie

Co za bałagan. Ale hej, jest splot!

Wyjaśnienie będzie jaśniejsze, jeśli po danej instrukcji można sprawdzić zawartość stosu . Aby to zrobić, po prostu wstaw X#0$%w tym miejscu. (Oznacza to: X# pokaż zawartość stosu, 0$nie pokazuj niczego pośrednio, %skomentuj resztę kodu). Na przykład zobacz stos zaraz po zwoju .

'()'       % 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
źródło
14
Luis Mendo, to imponujące. Głosowałbym dwa razy, gdybym mógł. Myślałem, że będzie to nieściśliwe wyzwanie Kołmogorowa. Dziękuję za udowodnienie, że się mylę!
Rohan Jhunjhunwala
3
@Rohan Dzięki za miłe słowa!
Luis Mendo
1
: D Nie ma problemu! : D
Rohan Jhunjhunwala,
3
+1 za to, :)co pojawia się w kodzie.
Erik the Outgolfer
2
@ Neil Zobacz jasną stronę życia ...
Erik the Outgolfer,
37

Perl, 93 bajty

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

Wymaga opcji wiersza poleceń -l71Mbignum=bpi, liczonej jako 14. \32Powinien zostać zastąpiony literalnym znakiem 26.

Przykładowe użycie

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

Perl, 111 bajtów

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

Wersja sparametryzowana. Wymaga opcji wiersza poleceń -nMbignum=bpi, liczonej jako 12.

Przykładowe użycie

$ 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
źródło
25

JavaScript (ES6), 187 174 bajtów

Jest to 1 bajt krótszy niż zwykły tekst.

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
źródło
1
Czy nie jest to jeden bajt krótszy niż console.log („”) + 12 * 11 znaków + 18 ukośników odwrotnych + 10 podziałów wierszy?
Tytus
@Titus - Masz rację. Zapomniałem policzyć ucieczki odwrotnego ukośnika. Dzięki!
Arnauld,
18
Mało interesujące, ale 2384626433832795028841971693 okazuje się być liczbą pierwszą.
ElementW
1
@ElementW - Zabawne, że o tym wspomniałeś, bo ja też to sprawdziłem. :)
Arnauld,
Czy zapisanie liczby w postaci heksadecymalnej i konwersja jej na ciąg pozwoli zaoszczędzić bajty?
Nic Hartley,
17

Python 2, 131 bajtów

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

Wspólny wysiłek Sp3000 i Lynn. Miedź też uratowała bajt! Link Ideone.

Lynn
źródło
To eleganckie +1
ElPedro
Powinno być możliwe zapisanie 1 bajtu poprzez usunięcie nawiasów w forpętli.
Miedzi
16

/// , 129 127 bajtów

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

Wypróbuj online!

Erik the Outgolfer
źródło
-2 bajtów jeśli nie /!/()()/!!!zamiast ()()()()()()i wymienić /#/|\n%%/z /#/|\n%/i dostosować resztę kodu, aby pracować z tym.
acrolith
@daHugLenny O dzięki, nie wiedziałem, że 4 * 3 to ważny kandydat na zastępcę. Jeśli chodzi o twoją drugą sugestię, myślę, że będzie ona dłuższa.
Erik the Outgolfer,
@daHugLenny ^^ Mogę potwierdzić, że twoja druga sugestia jest rzeczywiście dłuższa.
Erik the Outgolfer,
@DestructibleWatermelon Zrobiłem to celowo. Istnieją także inne twarze: -:, :-, :-i -__-.
Erik the Outgolfer
12

Bash, 153 bajty

cat << _
()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
_
Chris
źródło
9
Biorąc pod uwagę, jak wiele innych odpowiedzi wpadło w pułapkę tworzenia kodu dłużej niż drukowania dosłownego ciasta , myślę, że jest to rzeczywiście mądra odpowiedź. Co więcej, to tylko 153 bajty według mojej liczby.
Lynn,
3
@ Lynn Jednak po prostu zrzuca przykład na wyjście bez próby gry w golfa, więc jest to odradzane. Przynajmniej inne odpowiedzi podjęły trud ...
Rozpad Beta
Możesz usunąć spacje przed i po <<. A twoja bajt liczy 153 bajty.
TuxCrafting,
1
Czy echo '()()()()()()...\__\|'4 bajty nie są krótsze?
Neil
@ Lynn Cieszę się, że nie miałem tego problemu; Partia wymaga 100 bajtów narzutu, aby po prostu wydrukować ciasto.
Neil
9

Partia, 195 bajtów

@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
źródło
5

Turtlèd , 135 129 bajtów (nie konkuruje)

(interpreter nie jest tak naprawdę trochę buggèd (już:]) , ale nie wpływa na ten program )

Przekształcając i przepisując mój program, grałem w golfa ... sześć bajtów

A teraz muszę wyjaśnić ...

Nadal mogą być krótsze sondy


Przynajmniej najlepszym rozwiązaniem w tym języku jest nie tylko zapisywanie surowych danych ¯ \ _ (ツ) _ / ¯


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

Wypróbuj online

Wyjaśnienie

Szczerze mówiąc, nie opisuje to zbyt dobrze rzeczywistego programu, ale daje wskazówki na temat poleceń, więc możesz lepiej zrozumieć

#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

KOMPLEKSOWA RZECZ: NESTED LOOPS

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

Podczas gdy bieżąca komórka nie jest spacją {przesuń w lewo, wykonaj pętlę: (Podczas gdy komórka nie |, napisz bieżący znak zmiennej łańcuchowej (pamiętasz to pi?), Zwiększ wskaźnik łańcucha, przesuń w lewo), wykonaj pętlę: (gdy komórka nie \, przesuń w prawo), przesuń w górę, w lewo}

Zniszczalna cytryna
źródło
Dlaczego nie konkurować?
programista
brak współzawodnictwa oznacza, że ​​jest nowszy niż wyzwanie
Destructible Lemon
5

Fourier, 196 190 bajtów

Powiadomienie o nowej funkcji!

Kod

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

Wyjaśnienie

Ten program to moja pierwsza prezentacja funkcji w Fourierze:

Funkcje są zdefiniowane w następujący sposób:

|code goes here|f

Pierwszy potok rozpoczyna deklarację funkcji. Następnie umieść kod między rurami. Ostatni potok kończy deklarację funkcji. Na koniec fjest zmienna, w której funkcja jest przechowywana. Może to być dowolny znak, o ile nie jest to funkcja zarezerwowana.

Na przykład w moim kodzie jedną z funkcji jest:

|SaCaaSa|f

Gdzie zmienna Sprzechowuje liczbę 92 i Cprzechowuje liczbę 58.

Po wywołaniu funkcja wyświetla następujące dane:

\::\

Ponieważ jest to najbardziej powtarzająca się rzecz w cieście.

Podobnie, aby zagrać w golfa na wyjściu, użyłem pętli:

6(40a41ai^~i)

Który powtarza kod 40a41a6 razy. 40a41ana własnych wynikach:

()

Zatem sześciokrotne powtórzenie kodu powoduje:

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

W ten sposób powstaje skorupa ciasta.

Wypróbuj na FourIDE!

Ponieważ nie zaimplementowałem funkcji w interpretatorze Pythona, ten program nie będzie działał na http://tryitonline.net

Rozpad beta
źródło
4

Pyth, 89 bajtów

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

Wypróbuj online!

Zamień \xx(szesnastkowy) na odpowiedni znak ASCII, jeśli skopiujesz / wkleisz kod z tej odpowiedzi; zawiera znaki niedrukowalne w spakowanym ciągu, które SE odfiltrowuje.

Wyjaśnienie

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
wstaw nazwę_tutaj
źródło
4

Galaretka , 83 bajty

na pewno jeszcze całkiem golfabale

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

TryItOnline

W jaki sposób?

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
źródło
2
Wow, to najdłuższy program galaretki, jaki kiedykolwiek widziałem: o
Rozpad Beta
@BetaDecay bez wątpienia można to zrobić za pomocą 11 bajtów ...
Jonathan Allan
3

Python 2, 193 176 bajtów

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

Lub krótsza, nudniejsza odpowiedź:

print r"""()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|"""
acrolith
źródło
3
Czy wiesz, że print r'''(the pie)'''jest o 38 bajtów krótszy? :)
Lynn,
+1 za drugi wysiłek, ale użycie pojedynczych cudzysłowów sprawia, że ​​krótszy jest czas patrzenia. Liczba pikseli jest lepiej :)
ElPedro
3

C # 220 213 209 208 202 201 (171 *) bajtów

* Uważam, że jest to nieoryginalne i oszukiwanie

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

201 bajtów:

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 bajtów:

Jestem pewien, że jest tu coś do gry w golfa

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
źródło
Dziękuję za odpowiedź! Możesz zaoszczędzić co najmniej jeden bajt, usuwając dodatkowe miejsce w .Substring(j, i).
Copper
To było przeoczenie od automatycznego formatowania w VS, ale i tak zapisałem kilka innych sposobów =)
pinkfloydx33 18.09.16
Anonimowa funkcja zwracająca dosłownie ciasto jest> 25% krótsza: ()=>@"(pie)"ma 149 bajtów .
Lynn
Jest to również nudne i przypomina oszustwo. Reguły mówią: drukuj, a nie wracaj
pinkfloydx33 18.09.16
@ pinkfloydx33 Drukowanie i zwrot są domyślnie dozwolone zgodnie z konsensusem społeczności.
mbomb007,
3

PowerShell , 105 bajtów

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

Wypróbuj online!

Nie jestem pewien, jak nigdy nie odpowiedziałem na to wyzwanie ... Głosowałem za nim i kilkoma innymi odpowiedziami. No cóż, lepiej późno niż wcale?

To umieszcza sześć zrównoważonych parenów jako ciąg w potoku, a następnie dosłowny ciąg (zapisuje dwa bajty) dwóch kolejnych wierszy. Następnie przeglądamy pozostałe liczby, a każda iteracja zwiększa liczbę poprzedzających spacji ( $i) połączonych z \::<number>|. Na koniec tworzymy ciąg końcówki ciasta. Wszystkie te ciągi są pozostawione w potoku, a domniemany Write-Outputprzykleja nową linię między nimi.

To o 39 bajtów mniej niż samo wydrukowanie ciasta.

AdmBorkBork
źródło
3

Węgiel drzewny , 31 bajtów

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

Wypróbuj online!

Być może zastanawiasz się: co to za czary? Jak możesz się wypełnić UGPi? Cóż, Charcoal zaczyna otrzymywać wsparcie Wolfram Language, mając nadzieję, że pewnego dnia będzie konkurencyjny w kolejnych wyzwaniach!

Poprzednie, 71 bajtów

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

Wypróbuj online!

Gadatliwy

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

Zauważ, że jest inaczej, ponieważ deverbosifier automatycznie kompresuje ciągi i nie usuwa zbędnych poleceń.

Ze skompresowanymi łańcuchami, 52 bajty

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

wyjście 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..

Wypróbuj online!

Tylko ASCII
źródło
2

PHP, 170 bajtów

brak precyzji arytmetycznej Pi w PHP? Obliczanie zajmuje znacznie więcej miejsca niż Kopiowanie i wklejanie. Nie ma znaczenia, że ​​ostatnia cyfra tutaj jest wycięta, a nie zaokrąglona; ale w 64-bitowym Pi ostatnia cyfra jest zaokrąglana w górę.

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

Biegnij z php -r '<code>'

nieprzypisany podział

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);
Tytus
źródło
W danych wyjściowych brakuje 1 spacji (którą można naprawić, zmieniając 13ją za pomocą a 14). I z jakiegoś dziwnego powodu brakuje ci nawiasu zamykającego u góry. Dokonanie zmiany naprawia wynik.
Ismael Miguel
Odpowiedzi PHP potrzebują <?phpznacznika, w przeciwnym razie generują tylko stały wynik. PHP Witaj, świecie! właściwie zależy od tego. Jednak mówiąc o stałej wydajności, odpowiedź PHP, która zawiera dosłowne ciasto i żaden <?phpznacznik nie pobiłaby twojego o znaczną przewagę…
Lynn
@Lynn: PHP nie potrzebuje <?phptagu, kiedy go uruchomisz -r.
Tytus
2

Python 2, 183 171 bajtów

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

Naprawdę nie robi nic mądrego. Po prostu buduje duży ciąg, a następnie go drukuje.

EDYTOWAĆ

Zmniejszony do 171 po przeczytaniu odpowiedzi @ Lynn i nauce. Przepraszam, jeśli źle jest (bezwstydnie) ukraść ci kilka bajtów bez Twojej sugestii. Jeśli tak, proszę powiedzieć, a cofnę zmianę.

Wynik

python pi.pie.py

()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
ElPedro
źródło
Czy wiesz, że print r'''(the pie)'''jest 28 bajtów krótszy? :)
Lynn,
@Lynn Czy to nie oszustwo? ;-)
ElPedro
To nie jest oszustwo, po prostu niezbyt interesujące (i nie potrzebujemy tej odpowiedzi dla każdego języka, IMO. Odpowiedź bash jest wystarczająca). Bardziej jak coś, o czym chciałbyś wspomnieć, zamieszczając taką odpowiedź, aby potwierdzić, że twoja próba golfa zakończyła się stratą. Może nadal warto opublikować, na wypadek, gdyby ktoś widział sposób, aby wziąć twój pomysł na grę w golfa i go ulepszyć, być może pokonując naiwne podejście.
Peter Cordes,
Biorę twoje komentarze na pokład @Peter. nie starałem się być pozbawiony szacunku, stąd buźka. Każdy może po prostu wydrukować takie wyzwanie artystyczne ASCII. Jestem całkiem nowy i jestem tutaj, aby się uczyć. Jeśli to coś znaczy, dodałem komentarz i +1 do odpowiedzi Lynn, kiedy zobaczyłem, że nie jest to tylko drukowane oświadczenie, ale rozwiązałem ten problem w sposób, który całkowicie zdeklasował mój wysiłek. Nauczyłem się ...
ElPedro,
Tak długo, jak twoja odpowiedź ma inne podejście, możesz czerpać pomysły z innych odpowiedzi (w tym samym języku lub nie). Jedyne, co nie byłoby w porządku, to to, że twoja odpowiedź zakończyła się dokładnie takim samym kodem jak Lynn. Zwykle, jeśli zauważysz niewielką poprawę w czyjejś odpowiedzi, sugerujesz to w komentarzu. Ale jeśli masz wiele nowych pomysłów po zobaczeniu odpowiedzi innej osoby, możesz nawet opublikować ulepszoną wersję jako nową odpowiedź. Nie jestem do końca pewien co do etykiety, ale myślę, że jest w porządku, o ile twoja odpowiedź jest zupełnie inna.
Peter Cordes,
2

Rubin, 140 138 137 bajtów

Moje rozwiązanie tego problemu w ruby, to moja pierwsza odpowiedź na golfa: 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)}

Czytelna wersja i objaśnienie:

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

Nic naprawdę sprytnego, po prostu używając prostych pętli :)

Wynik:

()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
Linus
źródło
2
Witamy w PPCG! Miły pierwszy post!
Rɪᴋᴇʀ
2

Stax , 63 bajty

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

Uruchom i debuguj online!

Krótszy niż zaakceptowana odpowiedź MATL. Byłoby zdecydowanie krótsze, gdyby więcej cyfr było przechowywanych jako stała pi w Stax.

(Co to jest Pi<0w kodzie?)

Wyjaśnienie

Używa odpowiednika ASCII do wyjaśnienia, co oznacza

.()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
źródło
1

Java 7, 260 236 191 bajtów

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

Westchnienie, po prostu wyjście z ciasta jest krótsze, nawet przy wszystkich odwróconych ukośnikach ..>.>
Oto poprzednia odpowiedź z odrobiną pieniędzy, choć wciąż niezbyt ogólna lub fantazyjna ( 236 bajtów ):

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

Dość nudna odpowiedź, ponieważ po prostu generowanie wyniku bez zbyt wielu wymyślnych rzeczy jest krótsze w Javie niż ogólne podejście.

Kod niepoznany i testowy:

Wypróbuj tutaj.

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

Wynik:

()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
Kevin Cruijssen
źródło
1

Qbasic, 175 bajtów

?"()()()()()()":?"|\3.1415926|":?"|:\53589793|":?"\::\2384626|":?" \::\433832|":?"  \::\79502|":?"   \::\8841|":?"    \::\971|":?"     \::\69|":?"      \::\3|":?"       \__\|"
anonimowy 2
źródło
1

Lua, 152 bajtów

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

Spróbuj jak mogłem nie skompresować tego pi.

Lua jest po prostu zbyt gadatliwa, by to zrobić, może większy rozmiar pi, ale nie ten.

Inne rozwiązanie, 186 bajtów.

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

Irytujące pi Lua nie jest wystarczająco dokładne, aby nawet wypełnić pi. :(

ATaco
źródło
1

JavaScript, 172 bajty

Wklej do konsoli, aby uruchomić.

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
źródło
Witamy w PPCG! Dla pewności możesz sformatować swój kod za pomocą czterech spacji (zobacz moją edycję). Ponadto umieść liczbę bajtów w swoim programie na górze odpowiedzi (np Javascript: 100 bytes.).
Qwerp-Derp,
Wygląda na to, że występują dziwne błędy składniowe, czy możesz to naprawić?
programista
1

JavaScript (ES6), 170 bajtów 165 bajtów

jest nieco „oszukany”, ponieważ jeśli zostanie uruchomiony na konsoli, wyświetlona zostanie wartość zwracana

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

Po pewnym przejściu funkcja wygląda tak (funkcja musi zostać wywołana z parametrem o wartości 0):

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

Jeśli chcesz wywołać funkcję 167 bajtów:

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
źródło
1: Potrzebuje dodatkowych paren zamykających. 2: Zastąpienie "|\n"w |<newline>którym <newline>jest dosłownym nowej linii. 3: Dodaj y=>do początku, a to nie będzie oszustwo. 4: Witamy na stronie!
programista
1
@ programmer5000 dzięki za Twój wkład, użyłem go w moim najnowszym ulepszeniu. :-D
winner_joiner 20.04.17
Zaoszczędź 2 bajty, usuwając parametr ()otaczający v. Wydaje się, że twój wynik ma dodatkową przestrzeń przed 2. i 3. wierszem. Ponadto, nie musisz podawać 0jako argumentu, twoja funkcja będzie działać bez niego poprawnie i nie jest to dozwolone przez wyzwanie.
Kudłaty
tak, dziękuję, miałem przed wartością domyślną. :-D
winner_joiner
0

PHP, 142 bajty

Sneaky-sneaky :) phppo prostu drukuje wszystko, nie próbując interpretować ich jako kodu PHP, jeśli nie widzi żadnych <?php ?>par.

()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
iBug
źródło