चौकोर पाई का एक त्रिकोणीय टुकड़ा

Question

पेक का एक टुकड़ा बेक से प्रेरित है

चुनौती

दिए गए इनपुट 3 <= n <= 100और 3 <= y <= n, n x nदशमलव भाग के एक मैट्रिक्स का निर्माण pi( 14159...), शीर्ष बाएँ में शुरू। फिर, आकार के ऊपरी-दाएं त्रिभुज को लें y x yऔर इसे एक साथ मिलाएं। परिणामी संख्या को आउटपुट करें।

उदाहरण के लिए, निवेश के लिए n = 5, y = 3, निम्नलिखित मैट्रिक्स का निर्माण किया है

14159
26535
89793
23846
26433

फिर, ऊपरी-दाएँ 3 x 3त्रिकोण होगा

159
 35
  3

इतना 159353आउटपुट है।

इनपुट

दो पूर्णांक - nपाई के अंकों के वर्ग मैट्रिक्स के आकार का yप्रतिनिधित्व करते हैं , और ऊपरी-दाएँ त्रिकोण का प्रतिनिधित्व करते हैं - किसी भी सुविधाजनक प्रारूप में ।

उत्पादन

• परिणामी कटा हुआ और संक्षिप्त संख्या, या तो मुद्रित / स्क्रीन पर प्रदर्शित होती है, एक स्ट्रिंग के रूप में वापस आ जाती है, आदि।
• अनुगामी / अग्रणी व्हाट्सएप वैकल्पिक है, इसलिए जब तक कि आउटपुट में कोई व्हाट्सएप न हो (यानी, 159 35 3या जैसा अमान्य होगा)।
• ध्यान दें कि चूंकि हम स्पष्ट रूप से अंकों की तलाश कर रहे हैं pi, न कि एक अनुमान या गणितीय गणना, इसलिए मैट्रिक्स के अंतिम अंक को गोल नहीं करना चाहिए।

नियम

• यह कोड-गोल्फ है इसलिए गोल्फिंग के लिए सभी सामान्य नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।
• या तो एक पूर्ण कार्यक्रम या फ़ंक्शन स्वीकार्य हैं।
• मानक खामियों को मना किया जाता है।

उदाहरण

 n  y  output
-------------
 3  3  141923
 5  3  159353
 6  4  1592589383
 6  6  141592535893238643794
20 12  358979323846950288419715820974944628620899211706792306647223172745025559196615

Comments

धन्यवाद। साथ ही, क्या अंतिम अंक को गोल किया जा सकता है? कुछ जवाबों से ऐसा लगता है, और इससे बचना वास्तव में मुश्किल हो सकता है

— लुइस मेंडो

@LuisMendo यह एक अच्छी बात है। नहीं, अंतिम अंक की गोलाई नहीं होनी चाहिए, क्योंकि हम पाई के वास्तविक अंकों की तलाश कर रहे हैं, न कि किसी अनुमान या गणना की। मैं स्पष्ट कर दूंगा और उत्तरदाताओं के साथ सत्यापन करूंगा।

— AdmBorkBork

Answer 1

05AB1E , 19 बाइट्स

CP-1252 एन्कोडिंग का उपयोग करता है ।

nžs¦¦¹ôI£íRvyN>£J}R

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

व्याख्या

n=5, y=3 उदाहरण के लिए इस्तेमाल किया

nžs                  # push pi to n^2 digits
                     # STACK: 3.1415926535897932384626433
   ¦¦                # remove the first 2 chars
                     # STACK: 1415926535897932384626433
     ¹ô              # split into n*n matrix
                     # STACK: ['14159', '26535', '89793', '23846', '26433']
       I£            # keep the first y rows
                     # STACK: ['14159', '26535', '89793']
         íR          # reverse the list of rows and each individual row
                     # STACK: ['39798', '53562', '95141']
           v     }   # for each y,N (row, index) in the list
            yN>£J    # keep the first index+1 digits of the row and join to string
                     # STACK: 353951
                  R  # reverse the string
                     # STACK: 159353
                     # implicit print

Comments

10k के लिए बधाई!

— आउटगॉल्फ

Answer 2

पायथन 2 (सिम्पी के साथ), 100 बाइट्स

from sympy import*
lambda n,y:''.join(c for i,c in enumerate(`pi.round(n*n+1)`[2:])if i%n-i/n>n-y-1)

---

कोई सहानुभूति नहीं, 260 246 244 233 231 218 बाइट्स

p=lambda n,y,a=-30,b=10,c=3,d=2,e=0,f=5,s='',i=0:i<n*n and p(n,y,*[((2*b+a)*f,b*d,c*f,d+1,(b*(7*d)+2+(a*f))/(c*f),f+2,s,i),(10*(a-e*c),10*b,c,d,((10*(3*b+a))/c)-10*e,f,s+(str(e)[:i%n-i/n>n-y-1]),i+1)][4*b+a-c<e*c])or s

यह स्टेनली राबिनोविट्ज और स्टेन वैगन के "द स्पिगोट एल्गोरिथम फॉर पाई" को नियोजित करता है ।

मानक तर्क a,b,c,d,e,f=0,1,1,1,3,3पीआई के पहले अंक का उत्पादन करने के लिए होगा 3, क्योंकि यह आवश्यक नहीं है कि एल्गोरिथ्म को इस बिंदु पर शुरू करने से पहले उपज दिया जाता 1है, जो भले ही दो बाइट्स बचाता है aऔर bलंबे समय तक परिणाम के लिए स्लाइसिंग की आवश्यकता नहीं होती है और iयह शुरू हो सकता है 0के बजाय -1।

पिछले परीक्षण के मामले के लिए डिफ़ॉल्ट पुनरावर्तन सीमा का
उपयोग करता //है विभाजन के पहले उपयोग के लिए उपयोग करता है ताकि इसे str(v)बदल दिया जाए `v`(अन्यथा यह Lलंबे समय तक समाप्त हो जाएगा )।
repl.it

---

232 बाइट्स के लिए एक गैर-पुनरावर्ती संस्करण जो अंतिम परीक्षण मामले का भी मूल्यांकन करता है:

def p(n,y):
 a,b,c,d,e,f,i,s=-30,10,3,2,0,5,0,''
 while i<n*n:
    if 4*b+a-c<e*c:s+=`e`[:i%n-i/n>n-y-1];g=10*(a-e*c);e=((10*(3*b+a))//c)-10*e;b*=10;i+=1
    else:g=(2*b+a)*f;h=(b*(7*d)+2+(a*f))/(c*f);b*=d;c*=f;f+=2;d+=1;e=h
    a=g
 print s

repl.it (पहला इंडेंट एक स्पेस है, दूसरा इंडेंट एक टैब है)

Comments

वह "नो सिम्पी" संस्करण प्रभावशाली है :)

— एमिग्ना

मैंने एक लिंक जोड़ा, यह मेरा एल्गोरिथ्म नहीं है!

— जोनाथन एलन

... लेकिन अगर आप एक लाख अंकों के लिए "मेम" को "याद" करना चाहते हैं, तो यह शायद आसान है

— जोनाथन एलन

Answer 3

गणितज्ञ, 82 बाइट्स

Print@@Join@@Partition[RealDigits[Pi-3,10,#^2][[1]],#][[i,i-#2-1;;]]~Table~{i,#2}&

Comments

आप उपयोग कर सकते हैं #&@@के बजाय [[1]]।

— मार्टिन एंडर

@ टिम्मीड नोप। यह छंट जाता है। (n = 10, y = 10 देता है 1415926535979323846433832798841971937510749448164899259; अंतिम 9pi का 100 वां अंक है, और 101 वां अंक है 8- कोई गोल नहीं)

— JungHwan Min

Answer 4

MATL, 23 22 27 बाइट्स

1 बाइट ने @Luis को धन्यवाद दिया

UtEYPwY$IbH+&:)GetGi-&R!g)!

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

व्याख्या

        % Implicitly grab input (n)
Ut      % Square n and duplicate
E       % Multiply n^2 by 2
YP      % Pi literal
w       % Flip the stack
Y$      % Compute the first 2 * (n^2) digits of pi (accounts for rounding)
IbH+&:) % Grab the first n^2 digits after the decimal
Ge      % Reshape it into an n x n matrix in row-major ordering
t       % Duplicate this matrix
Gi-     % Grab the second input (y) and compute the difference between n and y
&R!     % Get the upper diagonal part and transpose to convert to lower diagonal
g)      % Convert it to a logical array and use it to select the digits of interest
!       % Transpose the result and implicitly display

Comments

@LuisMendo आह! मुझे पता था कि हमारे पास इसके लिए एक फंक्शन है लेकिन यह नहीं मिल सका। धन्यवाद!

— Suever

@TimmyD ध्यान देने योग्य है। अपडेट किया गया।

— स्वेवर

Answer 5

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

s/ /bpi++$_**2/e;$%=$';$%-=print/(.{$%})$/ for/\d{$`}/g

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

नमूना उपयोग

$ echo 3 3 | perl -nMbignum=bpi primo-square-pi.pl
141923

$ echo 5 3 | perl -nMbignum=bpi primo-square-pi.pl
159353

$ echo 6 4 | perl -nMbignum=bpi primo-square-pi.pl
1592589383

$ echo 6 6 | perl -nMbignum=bpi primo-square-pi.pl
141592535893238643794

$ echo 20 12 | perl -nMbignum=bpi primo-square-pi.pl
358979323846950288419715820974944628620899211706792306647223172745025559196615

Answer 6

सी #, 232 बाइट्स 268 बाइट्स

संपादित करें:

मैंने मूल रूप से विधि के बाहर पाई के लिए एक निरंतर स्ट्रिंग का उपयोग किया है, लेकिन ऐसा लगता है कि यह धोखा था। मुझे C # Math.PI मान का उपयोग करना है, जिसमें केवल 14 दशमलव स्थान हैं, इसलिए उच्चतमm मैं मूल्य उपयोग कर सकता हूं वह है 3. ड्राइंग बोर्ड पर वापस ...

golfed:

IEnumerable<string>f(int m,int t){var a=new string[m, m];var b=Math.PI.ToString().Replace("3.","").Substring(0,m*m).ToArray();var c=0;for(int i=0;i<m;i++){for(int j=0;j<m;j++){a[i, j]=b[c]+"";c++;}}c=0;while(t>0){for(int i=t;i>0;i--){yield return a[c,m-i];}t--;c++;}}}

Ungolfed:

  class ATriangularSliceOfSquaredPi
  {
    //http://www.piday.org/million/
    //const string p = "1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831";

    public IEnumerable<string> f(int m, int t)
        {
          var a = new string[m, m];

          //var b = p.Substring(0, m * m).ToArray();
          var b = Math.PI.ToString().Replace("3.", "").Substring(0, m * m).ToArray();

          var c = 0;

          for (int i = 0; i < m; i++)
          {
            for (int j = 0; j < m; j++)
            {
              a[i, j] = b[c] + "";
              c++;
            }
          }

          c = 0;

          while (t > 0)
          {
            for (int i = t; i > 0; i--)
            {
              yield return a[c, m - i];
            }
            t--;
            c++;
          }
        }
      }

सबसे छोटा जवाब नहीं, लेकिन मैं खुश था कि मैंने इसे हल कर लिया ...

टेस्ट आउटपुट:

m   t   output
3   3   141923

5 3 159353
6 4 1592589383
6 6 141592535893238643794
20 12 358979323846950288419715820974462862089921170679264664722317274504505519196615

Comments

अच्छा जवाब! अफसोस की बात है, अगर आप उपयोग कर रहे हैं pऔर यह भाषा में बिल्ट-इन नहीं है (जो मुझे पूरा यकीन है कि यह नहीं है), तो आपको इसे अपने बाइट स्कोर में शामिल करना होगा।

— AdmBorkBork

@ टिमिमद ओह नो! ठीक है, इसे मेरे साथ छोड़ दो !! अगर मैं बस अपने पीआई नंबर चिपकाता हूँ तो 400+ अधिक बाइट्स की आवश्यकता होगी, इसलिए मुझे लगता है कि एक अलग दृष्टिकोण की आवश्यकता है ... :)

— पीट आर्डेन