82

एक प्रोग्राम या फ़ंक्शन लिखें जो इस सटीक पाठ को प्रिंट या आउटपुट करता है (जिसमें 142 वर्ण शामिल हैं):

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

आपके प्रोग्राम को कोई इनपुट नहीं लेना चाहिए (उन भाषाओं को छोड़कर, जहां यह असंभव है, जैसे कि sed), और उपरोक्त पाठ (और केवल उपरोक्त पाठ को आउटपुट के रूप में प्रस्तुत करता है)। एक अनुगामी न्यूलाइन स्वीकार्य है।

यह कोड-गोल्फ है , इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।

— तांबा
स्रोत

9

@ रोहन झुनझुनवाला सबूत के लिए कि यह संकुचित हो सकता है, लुइस मेंडो ने किया ।

— आउटगॉल्फ

1

योग्य, मुझे गलत साबित किया गया है (और मुझे खुशी है!) बहुत प्रभावशाली है

— रोहन झुनझुनवाला

2

आपने उन्हें ठंडा किया है कि वे एक पूर्णांक इनपुट एन को एक स्लाइस का उत्पादन करने के लिए लेते हैं जिसकी ()शीर्ष पर संख्या एन है। यह बहुत ही जटिल होगा।

— user6245072

5

बस इतना पता है, आपको places 43 दशमलव स्थानों की आवश्यकता है।

— आउटगॉल्फ

4

जीवन के अर्थ के इतना करीब ....

— ए। मीराबाई

90

MATL , 70 68 67 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

क्या झंझट है। लेकिन हे, वहाँ एक दृढ़ विश्वास है!

यदि आप दिए गए कथन के बाद स्टैक सामग्री का निरीक्षण कर सकते हैं तो स्पष्टीकरण स्पष्ट हो जाएगा । ऐसा करने के लिए, बस X#0$%उस बिंदु पर डालें । (इसका मतलब है: X# स्टैक सामग्री दिखाएं, 0$स्पष्ट रूप से कुछ और प्रदर्शित न करें, %बाकी कोड टिप्पणी करें)। उदाहरण के लिए, कनवल्शन के ठीक बाद स्टैक देखें ।

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

लुइस मेंडो, यह प्रभावशाली है। अगर मैं कर सकता तो मैं दो बार उत्थान करूंगा। मैंने सोचा कि यह एक असंगत kolmogorov चुनौती होगी। मुझे गलत साबित करने के लिए धन्यवाद!

— रोहन झुनझुनवाला

3

@ रोहन अपनी तरह के शब्दों के लिए धन्यवाद!

— लुइस मेंडू

1

: डी कोई बात नहीं! : डी

— रोहन झुनझुनवाला

3

:)आपके कोड में +1 दिखाई देता है।

— एरिक आउटगॉल्फ

2

@ नील जीवन का उजला पक्ष देखें ...

— एरिक द आउटग्राफ

37

पर्ल, 93 बाइट्स

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

कमांड लाइन विकल्प की आवश्यकता होती है -l71Mbignum=bpi, जिसे 14. के रूप में गिना जाता है। \32इसे शाब्दिक वर्ण 26 द्वारा प्रतिस्थापित किया जाना चाहिए।

नमूना उपयोग

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

पर्ल, 111 बाइट्स

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

पैरामीटर संस्करण। -nMbignum=bpi12 के रूप में गिनी जाने वाली कमांड लाइन विकल्प की आवश्यकता है ।

नमूना उपयोग

$ 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
स्रोत

25

जावास्क्रिप्ट (ईएस 6), 187 174 बाइट्स

यह केवल सादे पाठ को प्रदर्शित करने की तुलना में 1 बाइट छोटा है।

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
स्रोत

1

क्या यह एक बाइट है जो कंसोल से कम है। ("") + 12 * 11 अक्षर + 18 बैकस्लैश + 10 लाइनब्रेक?

— टाइटस

@ टिट्स - आप सही कह रहे हैं। मैं भागने से बचने की गिनती करना भूल गया। धन्यवाद!

— अरनुलद

18

हल्का दिलचस्प है, लेकिन 238462643383279502828841971693 प्राइम होता है।

— तत्ववेद १

1

@ElementW - मजेदार है कि आपने इसका उल्लेख किया है, क्योंकि मैंने वह भी जांचा था। :)

— अरनुल्द

संख्या को हेक्स के रूप में लिखना और इसे स्ट्रिंग में परिवर्तित करना किसी भी बाइट को बचाएगा?

— निक हार्टले

17

पायथन 2, 131 बाइट्स

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

Sp3000 और लिन के बीच संयुक्त प्रयास। कॉपर ने एक बाइट भी बचाया! Ideone लिंक।

— लिन
स्रोत

यह सुरुचिपूर्ण +1

— ElPedro

आप कोष्ठक को हटाकर 1 बाइट को बचाने में सक्षम होना चाहिए for।

— कॉपर

16

/// , 129 127 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— आउटगोल्फर को एरिक करें
स्रोत

-2 बाइट्स यदि आप इसके /!/()()/!!!बजाय करते हैं ()()()()()()और इसके /#/|\n%%/साथ /#/|\n%/काम करने के लिए कोड के बाकी हिस्सों को समायोजित और बदलते हैं ।

— एक्रोलिथ

@daHugLenny ओह धन्यवाद, मुझे नहीं पता था 4 * 3 प्रतिस्थापन के लिए एक वैध उम्मीदवार था। आपके दूसरे सुझाव के लिए, मुझे लगता है कि यह लंबा होगा।

— आउटगॉल्फ

@daHugLenny ^ ^ मैं पुष्टि कर सकता हूं कि आपका दूसरा सुझाव वास्तव में लंबा है।

— आउटगॉल्फ

यह नहीं है, मुझे इसके साथ 127 बाइट्स मिले।

— एक्रोलिथ

@DestructibleWatermelon मैंने इसे जानबूझकर किया था। वहाँ भी अन्य चेहरे हैं: -:, :-, :-और -__-।

— आउटगॉल्फ

12

बैश, 153 बाइट्स

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

— क्रिस
स्रोत

9

यह देखते हुए कि शाब्दिक पाई को छापने की तुलना में कितने अन्य उत्तर उत्पादक कोड के जाल में गिर गए हैं , मुझे लगता है कि यह वास्तव में एक स्मार्ट कोड है। इसके अलावा, यह मेरी गिनती से केवल 153 बाइट्स है।

— लिन

3

@ लियन हालांकि, यह केवल गोल्फिंग के प्रयास के साथ आउटपुट के लिए उदाहरण को डंप कर रहा है, और इसलिए हतोत्साहित किया जाता है। कम से कम अन्य उत्तरों ने एक प्रयास किया ...

— बीटा डिके

आप रिक्त स्थान को पहले और बाद में निकाल सकते हैं <<। और आपका बाइटकाउंट 153 बाइट्स का है।

— TuxCrafting

1

नहीं है echo '()()()()()()...\__\|'4 बाइट कम?

— नील

@ मुझे खुशी है कि मुझे वह समस्या नहीं आई; बस पाई को प्रिंट करने के लिए बैच को ओवरहेड के 100 बाइट्स की आवश्यकता होती है।

— नील

9

बैच, 195 बाइट्स

@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

टर्टल , 135 129 बाइट्स (प्रतिस्पर्धा नहीं)

(दुभाषिया वास्तव में ~~थोड़ा~~ बग़दाद नहीं है (अब:]) ~~, लेकिन यह इस कार्यक्रम को प्रभावित नहीं करता है~~ )

अपने कार्यक्रम का पुनर्गठन और पुनर्लेखन करके, मैंने गोल्फ ... छह बाइट्स

और अब मुझे नई व्याख्या करनी है ...

हालांकि अभी भी कम जांच हो सकती है

इस लैंग में कम से कम सबसे अच्छा समाधान कच्चे डेटा (\ _ (best) _ / ¯ में नहीं लिख रहा है

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

इसे ऑनलाइन आज़माएं

व्याख्या

ईमानदारी से, यह बहुत अच्छी तरह से वास्तविक कार्यक्रम का वर्णन नहीं करता है, लेकिन यह आदेशों के बारे में संकेत देता है, इसलिए आप थोड़ा बेहतर समझ सकते हैं

#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

कॉम्प्लेक्स थिंग: नेस्टेड लूप्स

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

जबकि वर्तमान सेल स्पेस नहीं है {लेफ्ट, लेफ्ट को निष्पादित करें: (जबकि सेल नहीं।), स्ट्रिंग चर का वर्तमान वर्ण लिखें (उस pi को याद रखें?), इंक्रीमेंट स्ट्रिंग पॉइंटर, लेफ्ट को छोड़ें), लूप निष्पादित करें: (जबकि सेल नोट \ _, नहीं) दाएँ चलना), ऊपर जाना, बाएँ}

— विनाशकारी नींबू
स्रोत

गैर-प्रतिस्पर्धा क्यों?

— प्रोग्रामर

प्रतिस्पर्धा नहीं करने का मतलब यह चुनौती से नया है

— विनाशकारी नींबू

5

फूरियर, 196 190 बाइट्स

नया फीचर अलर्ट!

कोड

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

व्याख्या

यह कार्यक्रम फूरियर में कार्यों का मेरा पहला प्रदर्शन है:

कार्य इस प्रकार परिभाषित किए गए हैं:

|code goes here|f

पहला पाइप फ़ंक्शन की घोषणा शुरू करता है। फिर आप पाइप के बीच में कोड डालते हैं। अंतिम पाइप फ़ंक्शन की घोषणा को समाप्त करता है। अंततःf चर है जिसमें फ़ंक्शन संग्रहीत होता है। यह कोई भी वर्ण हो सकता है, जब तक कि यह आरक्षित कार्य नहीं है।

उदाहरण के लिए, मेरे कोड में, फ़ंक्शन s में से एक है:

|SaCaaSa|f

जहां वैरिएबल Sनंबर 92 को Cस्टोर करता है और 58 नंबर को स्टोर करता है।

जब बुलाया जाता है, तो फ़ंक्शन निम्न आउटपुट करता है:

\::\

चूंकि यह पाई में सबसे दोहराया जाने वाला काम है।

इसी तरह, आउटपुट को नीचे लाने के लिए, मैंने एक लूप का उपयोग किया है:

6(40a41ai^~i)

जो 40a41a6 बार कोड दोहराता है । 40a41aअपने स्वयं के आउटपुट पर:

()

इसलिए कोड को छह बार आउटपुट दोहरा रहा है:

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

जिससे पाई का क्रस्ट आउटपुट होता है।

यह चार वीडियो पर कोशिश करो!

_{क्योंकि मैंने पायथन इंटरप्रेटर में फ़ंक्शंस लागू नहीं किए हैं, यह प्रोग्राम http://tryitonline.net पर काम नहीं करेगा}

— बीटा डिके
स्रोत

4

पायथ, 89 बाइट्स

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

इसे ऑनलाइन आज़माएं!

\xxयदि आप इस उत्तर से कोड को कॉपी / पेस्ट करते हैं तो संबंधित ASCII वर्ण के साथ (हेक्साडेसिमल) बदलें ; इसमें पैक्ड स्ट्रिंग में अनपेक्षित वर्ण होते हैं जो एसई फ़िल्टर करता है।

व्याख्या

J_2        Sets J to -2
  .n0      Pi; returns 3.141592653589793
  ."(...)" Packed string; returns "2384626433832795028841971693"
 +         Concatenation; returns "3.1415926535897932384626433832795028841971693"
K          Sets K to that string
*"()"6     Repetition; returns "()()()()()()", which is implicitly printed with a newline
 r9Z       Range; returns [9, 8, 7, 6, 5, 4, 3, 2, 1] (Z is initialized to 0)
V          Loop through r9Z, using N as the loop variable
  *dJ      Repetition; d is initialized to " " (returns an empty string if J <= 0)
 p         Print without a newline
  ?!Z      Ternary; if not Z
   \|      then return "|"
   ?qZ9    else, ternary; if Z == 9
    "|:"   then return "|:"
    "\::"  else, return "\::"
 p         Print without a newline
  \\       One-character string; returns "\"
 p         Print without a newline
  :KZ+ZN   Slice; returns K[Z:Z+N], not including K[Z+N]
 p         Print without a newline
 \|        One-character string; returns "|", which is implicitly printed with a newline.
 =+ZN      Adds N to Z
 =hJ       Increments J by 1
)          Ends loop
 *dJ       Repetition; d is initialized to " "
p          Print without a newline
"\__\|"    Returns "\__\|", which is implicitly printed with a newline

— insert_name_here
स्रोत

4

जैली , 83 बाइट्स

निश्चित रूप से अभी भी काफी गोल्फबेल

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

TryItOnline

कैसे?

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

वाह, यह सबसे लंबा जेली कार्यक्रम है जिसे मैंने कभी देखा है: ओ

— बीटा डेके

@ BetaDecay कोई शक नहीं कि इसे 11 बाइट्स में किया जा सकता है ...

— जोनाथन एलन

3

पायथन 2, 193 176 बाइट्स

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

या एक छोटा, अधिक उबाऊ जवाब:

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

— acrolith
स्रोत

3

क्या आप जानते हैं कि print r'''(the pie)'''38 बाइट्स छोटी होती हैं? :)

— लिन

आपके दूसरे प्रयास के लिए +1 लेकिन एकल उद्धरणों का उपयोग करने से यह देखने में छोटा हो जाता है। पिक्सेल की गिनती बेहतर है :)

— ElPedro

3

सी # 220 213 209 208 202 201 _{(171 *)} बाइट्स

* मुझे यह अप्राप्य और धोखा लगता है

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

201 बाइट्स:

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 बाइट्स:

~~मुझे यकीन है कि यहां कुछ गोल्फ होने वाला है~~

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
स्रोत

जवाब के लिए धन्यवाद! आप अतिरिक्त स्थान को हटाकर कम से कम एक बाइट बचा सकते हैं .Substring(j, i)।

— कॉपर

यह वी.एस. में ऑटो-स्वरूपण से एक निरीक्षण था, लेकिन मैंने किसी भी तरह से एक गुच्छा बचा लिया =)

— Pinkfloydx33

पाई वर्बेटिम को लौटाने वाला एक अनाम फ़ंक्शन> 25% छोटा है: ()=>@"(pie)"149 बाइट्स है ।

— लिन

यह उबाऊ भी है और धोखा देने जैसा लगता है। नियम कहते हैं कि प्रिंट करें, न लौटें

— गुलाबीफ्लक्सएक्स 33

@ pinkfloydx33 मुद्रण और वापसी दोनों को समुदाय की सहमति के अनुसार डिफ़ॉल्ट रूप से अनुमति दी जाती है ।

— mbomb007

3

पॉवरशेल , 105 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यकीन नहीं होता कि कैसे मैंने कभी इस चुनौती का जवाब नहीं दिया ... मैंने इसे और कई अन्य उत्तरों को उकेरा। ओह ठीक है, बेहतर देर से कभी नहीं?

यह पाइप लाइन पर एक स्ट्रिंग के रूप में छह संतुलित parens डालता है, फिर अगली दो पंक्तियों का एक शाब्दिक स्ट्रिंग (दो बाइट्स बचाता है)। फिर, हम शेष संख्याओं के माध्यम से लूप करते हैं, प्रत्येक पुनरावृत्ति पूर्व निर्धारित रिक्त स्थान की संख्या को बढ़ाती है ( $i) के साथ \::<number>|। अंत में, हम पाई की नोक का एक स्ट्रिंग बनाते हैं। उन तारों को पाइप लाइन पर छोड़ दिया जाता है, और एक निहित के Write-Outputबीच एक नई रेखा चिपक जाती है।

यह सिर्फ पाई की छपाई से 39 बाइट्स कम है ।

— AdmBorkBork
स्रोत

3

चारकोल , 31 बाइट्स

×⁶()↙↓¹⁰↖↖¹⁰↓↓²↘⁸Ｍ↑__↖←¤:↗¤ＵＧPi

इसे ऑनलाइन आज़माएं!

आप सोच रहे होंगे: यह टोना क्या है? आप कैसे भर सकते हैं ＵＧPi? खैर, चारकोल को वुल्फराम भाषा का समर्थन मिलना शुरू हो गया है, इस उम्मीद में कि एक दिन यह अधिक चुनौतियों में प्रतिस्पर्धी हो सकता है!

पिछला, 71 बाइट्स

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

इसे ऑनलाइन आज़माएं!

वाचाल

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

ध्यान दें कि यह अलग है क्योंकि डिवर्बोसिफायर स्वचालित रूप से तारों को संपीड़ित करता है और निरर्थक आदेशों को नहीं हटाता है।

संपीड़ित स्ट्रिंग्स के साथ, 52 बाइट्स

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

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

इसे ऑनलाइन आज़माएं!

— ASCII-केवल
स्रोत

2

PHP, 170 बाइट्स

PHP में कोई arbriteath परिशुद्धता पी? गणना करना कॉपी और पेस्ट की तुलना में बहुत अधिक स्थान लेता है। इससे कोई फर्क नहीं पड़ता कि यहां अंतिम अंक कट गया है, गोल नहीं; लेकिन 64 बिट पाई में अंतिम अंक गोल हो जाता है।

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

साथ दौड़ो php -r '<code>'

अधूरा टूटना

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

— टाइटस
स्रोत

उत्पादन 1 अंतरिक्ष याद आ रही है (आपको लगता है कि बदलने के द्वारा ठीक कर सकते हैं जो 13एक साथ 14)। और, कुछ विचित्र कारण के लिए, आप शीर्ष पर बंद कोष्ठक को याद कर रहे हैं। परिवर्तन करना आउटपुट को ठीक करता है।

— इस्माईल मिगुएल

PHP के जवाब की जरूरत है <?php टैग , अन्यथा वे निरंतर उत्पादन करते हैं। PHP नमस्कार, विश्व! वास्तव में इस पर निर्भर करता है। हालांकि, निरंतर आउटपुट की बात करें तो, PHP का जवाब है कि बस शाब्दिक केक होता है और कोई भी <?phpटैग नहीं होता है जो आपको एक बड़े अंतर से हरा देगा ...

— लिन

@Lynn: <?phpजब आप इसे चलाते हैं तो PHP को टैग की आवश्यकता नहीं होती है -r।

— टाइटस

2

पायथन 2, 183 171 बाइट्स

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

वास्तव में चतुर कुछ भी नहीं करता है। बस एक बड़ी स्ट्रिंग बनाता है फिर इसे प्रिंट करता है।

संपादित करें

@ लिन के जवाब और सीखने के बाद 171 तक कम हो गए। क्षमा करें यदि यह गलत है (बेशर्मी से) आप इसे सुझाव दिए बिना आपसे कुछ बाइट्स चोरी करते हैं। कृपया मुझे बताएं यदि ऐसा है और मैं परिवर्तन को वापस लाऊंगा।

उत्पादन

python pi.pie.py

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

— ElPedro
स्रोत

क्या आप जानते हैं कि print r'''(the pie)'''28 बाइट्स छोटी होती हैं? :)

— लिन

@ लियन है कि धोखा नहीं है? ;-)

— ElPedro

यह धोखा नहीं है, बस बहुत दिलचस्प नहीं है (और हमें हर भाषा, IMO के लिए उस जवाब की आवश्यकता नहीं है। मार जवाब पर्याप्त है)। इस तरह का जवाब देते समय कुछ और जैसा आप उल्लेख करना चाहते हैं, यह स्वीकार करने के लिए कि आपके गोल्फ के प्रयास को नुकसान हुआ है। शायद अभी भी पोस्ट करने के लायक है कि कोई और आपके गोल्फ विचार लेने और उस पर सुधार करने का एक तरीका देखता है, शायद भोली दृष्टिकोण को हराकर।

— पीटर कॉर्ड्स

मैं आपकी टिप्पणियों को @Peter पर लेता हूं। मैं अपमानजनक होने की कोशिश नहीं कर रहा था इसलिए स्माइली। कोई भी इस तरह एक ASCII कला चुनौती का प्रिंट आउट ले सकता है। मैं इसके लिए बहुत नया हूं और सीखने के लिए यहां हूं। अगर इसका मतलब कुछ भी है तो मैंने लिन के जवाब पर एक टिप्पणी और +1 किया, जब मैंने देखा कि यह सिर्फ एक प्रिंट स्टेटमेंट नहीं था, लेकिन इस मुद्दे को इस तरह से संबोधित किया जिसने मेरे प्रयास को पूरी तरह से रेखांकित किया। मैंने सीखा है ...

— ElPedro

जब तक आपके उत्तर का दृष्टिकोण अलग है, तब तक अन्य उत्तरों (उसी भाषा में या नहीं) से विचार प्राप्त करना ठीक है। केवल एक चीज जो ठीक नहीं होगी वह यह है कि यदि आपका उत्तर बिल्कुल उसी कोड के साथ समाप्त हो गया है जैसा कि लिन का है। आमतौर पर यदि आपको किसी और के उत्तर में एक छोटा सा सुधार दिखाई देता है, तो आप उसे टिप्पणी में सुझाएंगे। लेकिन अगर आपके पास किसी और के उत्तर को देखने के बाद कई नए विचार हैं, तो आप अपने उन्नत संस्करण को नए उत्तर के रूप में भी पोस्ट कर सकते हैं। मैं इस के शिष्टाचार के बारे में पूरी तरह से निश्चित नहीं हूं, लेकिन मुझे लगता है कि यह तब तक ठीक है जब तक आपका जवाब काफी अलग है।

— पीटर कॉर्ड्स

2

रूबी, 140 138 137 बाइट्स

रूबी में इस समस्या का मेरा समाधान, यह मेरा पहला कोड गोल्फ उत्तर है: डी

[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)}

पठनीय संस्करण और स्पष्टीकरण:

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

कुछ भी नहीं वास्तव में चालाक, बस कुछ सरल छोरों का उपयोग :)

आउटपुट:

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

— लीनुस
स्रोत

2

PPCG में आपका स्वागत है! अच्छी पहली पोस्ट!

— R

2

स्टेक्स , 63 बाइट्स

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

भागो और डिबग ऑनलाइन!

स्वीकृत MATL उत्तर की तुलना में कम है। यह निश्चित रूप से छोटा होगा अगर स्टैक्स में स्थिर पाई के रूप में अधिक अंक संग्रहीत किए गए थे।

( Pi<0कोड में वह क्या है ?)

व्याख्या

समझाने के लिए ASCII के बराबर का उपयोग करता है, जो है

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

जावा 7, 260 236 191 बाइट्स

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

आहें भरते हुए, केवल पाई को छोटा किया जाता है, यहां तक कि सभी बच गए बैकस्लैश के साथ ..>।>
यहां पिछले जवाब का एक छोटा सा खर्च है, हालांकि अभी भी बहुत सामान्य या फैंसी नहीं है ( 236 बाइट्स ):

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

एक बहुत ही उबाऊ उत्तर, क्योंकि बहुत अधिक फैंसी चीजों के बिना परिणाम का उत्पादन केवल जावा में एक सामान्य दृष्टिकोण से कम है।

Ungolfed और परीक्षण कोड:

इसे यहाँ आज़माएँ।

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

आउटपुट:

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

— केविन क्रूज़सेन
स्रोत

1

Qbasic, 175 बाइट्स

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

— anonymous2
स्रोत

1

लूआ, 152 बाइट्स

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

कोशिश करें कि मैं इस पाई को संकुचित न कर सकूं।

लुआ यह करने के लिए बहुत ही क्रियात्मक है, शायद अधिक आकार का एक पाई, लेकिन यह नहीं।

एक अन्य समाधान, 186 बाइट्स।

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

वार्षिक रूप से लुआ की पाई इतनी सटीक नहीं है कि वह पाई को भी भर सके। :(

— Ataco
स्रोत

1

जावास्क्रिप्ट, 172 बाइट्स

चलाने के लिए अपने कंसोल में चिपकाएँ।

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)

— काजल चौधरी
स्रोत

PPCG में आपका स्वागत है! बस इतना पता है, आप अपने कोड को चार स्थानों के साथ प्रारूपित कर सकते हैं (मेरा संपादन देखें)। इसके अलावा, अपने कार्यक्रम में अपने जवाब के शीर्ष पर बाइट्स की मात्रा डालें (जैसे Javascript: 100 bytes)।

— Qwerp-Derp

लगता है कि अजीब सिंटैक्स त्रुटियां हैं, क्या आप उन्हें ठीक कर सकते हैं?

— प्रोग्रामर

1

जावास्क्रिप्ट (ईएस 6), ~~170 बाइट्स~~ 165 बाइट्स

एक बिट "धोखा" है, क्योंकि यदि कंसोल पर चलाया जाता है, तो रिटर्न मान प्रदर्शित किया जाएगा

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

कुछ टीक करने के बाद, फ़ंक्शन ऐसा दिखता है (फ़ंक्शन को मान 0 के साथ पैरामीटर के साथ बुलाया जाना चाहिए):

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

यदि आप फ़ंक्शन को 167 बाइट्स कॉल करना चाहते हैं:

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
स्रोत

1: अतिरिक्त बंद करने की जरूरत है। 2: जहां एक शाब्दिक newline है के "|\n"साथ बदलें । 3: शुरुआत में जोड़ें और यह धोखा नहीं होगा। 4: साइट पर आपका स्वागत है! |<newline><newline>y=>

— प्रोग्रामर

1

@ programmer5000 आपके इनपुट के लिए धन्यवाद, मैंने इसका उपयोग अपने नवीनतम ट्वीक पर किया। :-D

— विजेता_जॉइनर

पैरामीटर को ()संलग्न करके 2 बाइट्स सहेजें v। लगता है कि आपका आउटपुट 2 और 3 लाइनों के सामने एक अतिरिक्त जगह है। इसके अलावा, आपको 0एक तर्क के रूप में पारित करने की आवश्यकता नहीं है, आपका कार्य इसके बिना ठीक काम करेगा और इसे चुनौती द्वारा अनुमति नहीं है।

— झबरा

हाँ धन्यवाद, मैं डिफ़ॉल्ट मूल्य से पहले था। :-D

— विजेता_जॉइनर

0

PHP, 142 बाइट्स

डरपोक-डरपोक :) phpबस सब कुछ छाप देता है बिना उन्हें बताए PHP कोड के रूप में व्याख्या करने की कोशिश करता है अगर यह किसी भी <?php ?>जोड़े को नहीं देखता है ।

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

— iBug
स्रोत

पाई का एक टुकड़ा सेंकना

MATL , 70 68 67 बाइट्स

व्याख्या

पर्ल, 93 बाइट्स

पर्ल, 111 बाइट्स

जावास्क्रिप्ट (ईएस 6), 187 174 बाइट्स

पायथन 2, 131 बाइट्स

/// , 129 127 बाइट्स

बैश, 153 बाइट्स

बैच, 195 बाइट्स

टर्टल , 135 129 बाइट्स (प्रतिस्पर्धा नहीं)

व्याख्या

कॉम्प्लेक्स थिंग: नेस्टेड लूप्स

फूरियर, 196 190 बाइट्स

कोड

व्याख्या

पायथ, 89 बाइट्स

व्याख्या

जैली , 83 बाइट्स

पायथन 2, 193 176 बाइट्स

सी # 220 213 209 208 202 201 (171 *) बाइट्स

पॉवरशेल , 105 बाइट्स

चारकोल , 31 बाइट्स

पिछला, 71 बाइट्स

वाचाल

संपीड़ित स्ट्रिंग्स के साथ, 52 बाइट्स

xxd आउटपुट

PHP, 170 बाइट्स

पायथन 2, 183 171 बाइट्स

रूबी, 140 138 137 बाइट्स

स्टेक्स , 63 बाइट्स

व्याख्या

जावा 7, 260 236 191 बाइट्स

Qbasic, 175 बाइट्स

लूआ, 152 बाइट्स

जावास्क्रिप्ट, 172 बाइट्स

PHP, 142 बाइट्स

सी # 220 213 209 208 202 201 _{(171 *)} बाइट्स