पाई का nth दशमलव ज्ञात करें

Question

पहले से ही 30 चुनौतियाँ हैं जो पाई के लिए समर्पित हैं, लेकिन एक भी व्यक्ति आपको nth दशमलव को खोजने के लिए नहीं कहता है, इसलिए ...

चुनौती

0 <= n <= 10000Pi के nth दशमलव को प्रदर्शित करने की सीमा में किसी भी पूर्णांक के लिए ।

नियम

• दशमलव प्रत्येक संख्या के बाद हैं 3.
• आपका कार्यक्रम एक समारोह, या एक पूर्ण कार्यक्रम हो सकता है
• आपको परिणाम 10 बेस में होना चाहिए
• आप nकिसी भी उपयुक्त इनपुट विधि (स्टडिन, इनपुट), फंक्शन पैरामीटर्स, ...) से प्राप्त कर सकते हैं, लेकिन हार्डकोड नहीं
• यदि आप अपनी पसंद की भाषा के मूल निवासी हैं, तो आप 1-आधारित अनुक्रमणिका का उपयोग कर सकते हैं
• आपको अमान्य इनपुट ( n == -1, n == 'a'या n == 1.5) से निपटना नहीं है
• यदि वे कम से कम 10k डेसीमल तक का समर्थन करते हैं, तो बिल्डिन्स को अनुमति दी जाती है
• रनटाइम कोई फर्क नहीं पड़ता, क्योंकि यह सबसे छोटे कोड के बारे में है और सबसे तेज़ कोड नहीं है
• यह कोड-गोल्फ है , बाइट्स जीत में सबसे छोटा कोड है

परीक्षण के मामलों

f(0)     == 1
f(1)     == 4 // for 1-indexed languages f(1) == 1
f(2)     == 1 // for 1-indexed languages f(2) == 4
f(3)     == 5
f(10)    == 8
f(100)   == 8
f(599)   == 2
f(760)   == 4
f(1000)  == 3
f(10000) == 5

संदर्भ के लिए, यहाँ पीआई के पहले 100k अंक हैं।

Comments

निर्मित-इन? जैसेstr(pi())[n+2]

— प्रिमो जूल

निकटतम डुओ टारगेट IMO , पीआई की छंटनी की गई अंक संशक्तियों की गणना कर रहे हैं (पैरामीटर को ओवरलोड करते हैं, या यह इस चुनौती के लिए सिर्फ एक परिमित अंतर होगा), Transmit pi बिल्कुल (एक इंडेक्स जोड़ता है और कुछ प्रिंटिंग को दबाता है), और Pi विंडो एन्क्रिप्शन ।

— पीटर टेलर

@ स्वेच्छाचारिता! यह नियम सिर्फ यह

— बताने के

मैं परीक्षण के मामलों में f (599) जोड़ने का सुझाव देता हूं, क्योंकि यह गलत हो जाना आसान हो सकता है (आपको लगभग 3 डेसीमल सटीक सटीकता की आवश्यकता है)।

— 16

इसके अलावा f (760) = 4, जो क्रम 4 999999 8 से शुरू होता है , गलत तरीके से गोल करना आसान है।

— एंडर्स कासोर्ग

Answer 1

05AB1E, 3 बाइट्स

žs¤

व्याख्या की

žs   # push pi to N digits
  ¤  # get last digit

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

1-आधारित अनुक्रमण का उपयोग करता है।
100k अंकों तक का समर्थन करता है।

Comments

Pi से n अंक गोल नहीं होते?

— बसुकक्सुआन

@busukxuan नहीं। इसने 100k अंकों के लिए pi के पूर्वनिर्धारित स्थिरांक का उपयोग किया और उनमें से N को पुनः प्राप्त किया।

— एमिग्ने जूल

@Emigna यह बहुत आसान है। अच्छा समाधान।

— स्वेवर

शॉर्ट और शार्प, PCG अपने सबसे अच्छे रूप में

— Xylius

Answer 2

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

n=input()+9
x=p=5L**7
while~-p:x=p/2*x/p+10**n;p-=2
print`x/5`[-9]

इनपुट स्टड से लिया गया है।

---

नमूना उपयोग

$ echo 10 | python pi-nth.py
8

$ echo 100 | python pi-nth.py
8

$ echo 1000 | python pi-nth.py
3

$ echo 10000 | python pi-nth.py
5

Comments

एल्गोरिथ्म में n का उपयोग करने के बारे में सावधान रहें ... 599 के लिए आउटपुट 2 होना चाहिए, न कि 1. आप यह निर्दिष्ट करना चाह सकते हैं कि आप अजगर 2 का उपयोग कर रहे हैं।

— aditsu

@aditsu नवीनीकृत। सभी n । 1000 के लिए पुष्टि की गई ।

— प्रिमो जूल

यदि आप nइनपुट प्लस 9 को लेते हैं, तो आप पैरेन्स से बच सकते हैं।

— xnor

@xnor डीओ। धन्यवाद;)

— प्रिमो

इस एल्गोरिथ्म द्वारा उत्पन्न पहले कुछ अंक '3.141596535897932 ...' हैं जो 5 और 6. स्थानों के बीच '2' को याद कर रहे हैं? क्योंकि ऐसा तब है जब पायथन 2 के `` ऑपरेटर Lको स्ट्रिंग में जोड़ना शुरू होता है ।

— एंडर्स कासोर्ग

Answer 3

बैश + कोरुटिल्स, 60 49 बाइट्स

echo "scale=10100;4*a(1)"|bc -l|tr -d '\\\n'|cut -c$(($1+2))

bc -l<<<"scale=$1+9;4*a(1)-3"|tr -dc 0-9|cut -c$1

डेनिस द्वारा सुधार किया गया । धन्यवाद!

सूचकांक एक-आधारित है।

Answer 4

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

मेरे स्कोर को 2 बाइट्स बढ़ाने के लिए @aditsu का धन्यवाद

अंत में एक एल्गोरिथ्म जो 2 सेकंड के भीतर पूरा कर सकता है।

n=10**10010
a=p=2*n
i=1
while a:a=a*i/(2*i+1);p+=a;i+=1
lambda n:`p`[n+1]

Ideone यह!

इसकी टेलर श्रृंखला का उपयोग pi = 4*arctan(1)करते हुए सूत्र का उपयोग करता है arctan(1)।

Comments

काफी तेज। 1-अनुक्रमण अजगर के मूल निवासी नहीं है, यद्यपि। अंतिम बार मुझे याद है (आमतौर पर मैं थोड़ी देर के लिए निष्क्रिय रहा हूं), आम सहमति यह थी कि कार्यों को परिभाषित करने की आवश्यकता है, जैसे f=lambda n:...।

— प्रिमो जूल

यहाँ लगभग हर लम्बा गुमनाम है (आप इस साइट में पायथन में उत्तर खोज सकते हैं)

— लीक नून

प्रासंगिक मेटा पोस्ट । अपने कोड चलाने के बाद नियम 1 और 3 (के उल्लंघन में हो रहा है, वहाँ समारोह संदर्भ कब्जा करने के लिए कोई रास्ता नहीं है, समारोह परिभाषा प्रत्येक इनपुट (के लिए टाइप करने की आवश्यकता होगी (lambda n:`p`[n+1])(1), (lambda n:`p`[n+1])(2), ...)।

— Primo

आप सीधे कोड नहीं चला सकते हैं। यह importपहले से बयान देने के समान है , बस यह पहले से कुछ वैश्विक चर बनाता है।

— लीक नून

i=3 while a:a=i/2*a/i;p+=a;i+=24 के लिए

— प्राइमो जूल

Answer 5

MATL, 11 10 बाइट्स

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

YPiEY$GH+)

यह समाधान 1-आधारित अनुक्रमण का उपयोग करता है

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

सभी परीक्षण मामले

व्याख्या

YP  % Pre-defined literal for pi
iE  % Grab the input and multiply by 2 (to ensure we have enough digits to work with)
Y$  % Compute the first (iE) digits of pi and return as a string
G   % Grab the input again
H+  % Add 2 (to account for '3.') in the string
)   % And get the digit at that location
    % Implicitly display the result

Comments

@LuisMendo ओह, मुझे लगता है कि आउटपुट पहले से ही एक स्ट्रिंग है। रवींद्र!

— स्वेवर

@LuisMendo ओह, मैं वास्तव में ऐसा कभी नहीं सोचा था। मैं हमेशा YPप्रतीकात्मक टूलबॉक्स के अपने परीक्षण में उपयोग करता हूं

— Suever

क्या वास्तव में YP की अनुमति है? प्रश्न कहता है कि अगर यह <= 10k अंकों का समर्थन करता है, तो इसकी अनुमति है

— Busukxuan

@ सेवर ओपी ने "कम से कम" के बजाय "अप" कहा। मेरी समझ का मतलब है कि समर्थन करने के लिए> 10k निषिद्ध है।

— बुसुकुआन जुआन

@Suever हाँ, मुझे लगता है कि मैं हो सकता है, यद्यपि मैं इसे करने का विरोध नहीं कर सकता। मैंने अपना ऋषि उत्तर सिर्फ उसी के कारण मिटा दिया।

— 14uk में Busukxuan

Answer 6

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

RealDigits[Pi,10,1,-#][[1,1]]&

---

f=%

f@0
f@1
f@2
f@3
f@10
f@100
f@599
f@760
f@1000
f@10000

1
4
1
5
8
8
2
4
3
5

Answer 7

ऋषि, 32 25 बाइट्स

lambda d:`n(pi,9^5)`[d+2]

इस तरह की भाषा में मेरा पहला जवाब।

nराउंड pi17775 अंकों के लिए।

Comments

आपको printकॉल की आवश्यकता है , अन्यथा यह एक स्निपेट है जो केवल REPL में काम करता है।

— Mego

: यह (सैद्धांतिक) किसी भी इनपुट के लिए काम करता हैlambda d:`n(pi,digits=d+5)`[-4]

— Mego

@ वहाँ "99999" रन नहीं हैं?

— बसुकक्सुआन

@Mego लेकिन फिर "9" रन भी लंबा होगा। मुझे यकीन नहीं है कि अगर लंबाई को दोगुना करने से यह सार्वभौमिक हो सकता है, लेकिन मुझे लगता है कि अनंत बंदर प्रमेय के कारण भी ऐसा नहीं कर सकते हैं: en.wikipedia.org/wiki/Infinite_monkey_theorem

— busukuanuan

@busukxuan यदि आप यादृच्छिक के रूप में of के असंबंधित अंकों को मॉडल करते हैं, तो आप निश्चित रूप से मनमाने ढंग से 9 के लंबे रन की उम्मीद करते हैं (और हमारे पास असली π से अलग होने की उम्मीद करने का कोई कारण नहीं है, हालांकि हमने यह साबित नहीं किया है), लेकिन आप केवल एक की उम्मीद करते हैं गायब होने की संभावना के साथ 9 एस के लंबे समय तक चलने की संभावना (हालांकि फिर से, हमने यह साबित नहीं किया है कि वास्तविक unexpected अप्रत्याशित रूप से व्यवहार नहीं करता है)। हमें कम से कम नौ 9 के रन मिले हैं, जो मुझे लगता है कि [-8]प्रस्ताव को तोड़ने के लिए पर्याप्त है ।

— एंडर्स कासोर्ग

Answer 8

CJam, 32

7e4,-2%{2+_2/@*\/2e10005+}*sq~)=

इसे ऑनलाइन आज़माएं (यह थोड़ा धीमा है)

Answer 9

गणितज्ञ, २३ २१ बाइट्स

⌊10^# Pi⌋~Mod~10&

सेजमैथ, 24 बाइट्स

lambda n:int(10^n*pi)%10

Comments

@LLAMnYP मैंने यह कोशिश की, लेकिन लगता है कि गणितज्ञ को Piऔर ⌋(या बीच #और ⌋अगर गुणा भाग गया है) के बीच जगह की आवश्यकता होती है , तो बचत गायब हो जाती है।

— एंडर्स कासोर्ग

वास्तव में यह गणितज्ञ ऑनलाइन (मैं कंसोल संस्करण का उपयोग कर रहा था) में काम करता है, इसलिए मैं इसे ले लूंगा, मुझे लगता है।

— एंडर्स कासोर्ग

ये अलग-अलग उत्तर होने चाहिए। हालांकि वे एक ही रणनीति का उपयोग करते हैं, वे एक ही भाषा के पास कहीं नहीं हैं।

— मेगो

@Mego मैंने जो नीति पाई है वह कहती है कि विभिन्न भाषाओं में उत्तर बहुत समान नहीं हो सकते। (यह सुझाव देने वाला उत्तर जो स्वीकार नहीं किया गया था।) क्या आप किसी अन्य नीति या केवल एक प्राथमिकता का उल्लेख कर रहे हैं?

— एंडर्स कासोर्ग

Answer 10

जे , 19 15 बाइट्स

10([|<.@o.@^)>:

पूर्णांक n लेता है और p के n ^वें अंक को आउटपुट करता है । शून्य-आधारित अनुक्रमण का उपयोग करता है। प्राप्त करने के लिए n ^वें अंकों, गणना अनुकरणीय बार 10 ^{n +1} , कि मूल्य के फर्श ले, और फिर इसे सापेक्ष 10 ले।

प्रयोग

इनपुट एक विस्तारित पूर्णांक है।

   f =: 10([|<.@o.@^)>:
   (,.f"0) x: 0 1 2 3 10 100 599 760 1000
   0 1
   1 4
   2 1
   3 5
  10 8
 100 8
 599 2
 760 4
1000 3
   timex 'r =: f 10000x'
1100.73
   r
5

मेरी मशीन पर, 10000 ^वें अंक की गणना करने में लगभग 18 मिनट लगते हैं ।

व्याख्या

10([|<.@o.@^)>:  Input: n
             >:  Increment n
10               The constant n
           ^     Compute 10^(n+1)
        o.@      Multiply by pi
     <.@         Floor it
   [             Get 10
    |            Take the floor modulo 10 and return

Answer 11

क्लोजर, 312 बाइट्स

(fn[n](let[b bigdec d #(.divide(b %)%2(+ n 4)BigDecimal/ROUND_HALF_UP)m #(.multiply(b %)%2)a #(.add(b %)%2)s #(.subtract % %2)](-(int(nth(str(reduce(fn[z k](a z(m(d 1(.pow(b 16)k))(s(s(s(d 4(a 1(m 8 k)))(d 2(a 4(m 8 k))))(d 1(a 5(m 8 k))))(d 1(a 6(m 8 k)))))))(bigdec 0)(map bigdec(range(inc n)))))(+ n 2)))48)))48)))

इसलिए, जैसा कि आप शायद बता सकते हैं, मुझे नहीं पता कि मैं क्या कर रहा हूं। यह किसी भी चीज़ से अधिक हास्यपूर्ण हो गया। मैंने Google को "p से n अंक" दिया, और Bailey – Borwein-Plouffe सूत्र के लिए विकिपीडिया पृष्ठ पर समाप्त हुआ । सूत्र को पढ़ने के लिए बस मुश्किल से पर्याप्त कैलकुलस (?) को जानने के बाद, मैं इसे क्लूजुर में अनुवाद करने में कामयाब रहा।

अनुवाद स्वयं उतना कठिन नहीं था। सूत्र की आवश्यकता के बाद से कठिनाई n-अंको तक सटीकता को संभालने से हुई (Math/pow 16 precision); जो वास्तव में बहुत तेज हो जाता है। मुझे इसके लिए BigDecimalहर जगह उपयोग करने की आवश्यकता थी , जो कि वास्तव में चीजों को फूला हुआ था।

Ungolfed:

(defn nth-pi-digit [n]
  ; Create some aliases to make it more compact
  (let [b bigdec
        d #(.divide (b %) %2 (+ n 4) BigDecimal/ROUND_HALF_UP)
        m #(.multiply (b %) %2)
        a #(.add (b %) %2)
        s #(.subtract % %2)]
    (- ; Convert the character representation to a number...
      (int ; by casting it using `int` and subtracting 48
         (nth ; Grab the nth character, which is the answer
           (str ; Convert the BigDecimal to a string
             (reduce ; Sum using a reduction
               (fn [sum k]
                 (a sum ; The rest is just the formula
                       (m
                         (d 1 (.pow (b 16) k))
                         (s
                           (s
                             (s
                               (d 4 (a 1 (m 8 k)))
                               (d 2 (a 4 (m 8 k))))
                             (d 1 (a 5 (m 8 k))))
                           (d 1 (a 6 (m 8 k)))))))
               (bigdec 0)
               (map bigdec (range (inc n))))) ; Create an list of BigDecimals to act as k
           (+ n 2)))
      48)))

कहने की ज़रूरत नहीं है, मुझे यकीन है कि अगर आपको कोई गणित पता है तो इस बारे में जाने का एक आसान तरीका है।

(for [t [0 1 2 3 10 100 599 760 1000 10000]]
  [t (nth-pi-digit t)])

([0 1] [1 4] [2 1] [3 5] [10 8] [100 8] [599 2] [760 4] [1000 3] [10000 5])

Comments

मुझे बाद में एहसास हुआ कि मानक ऑपरेटर वास्तव में बड़े दशमलव पर काम करते हैं, इसलिए शीर्ष पर शॉर्टकट अनावश्यक हैं। मैं इसे किसी बिंदु पर ठीक करता हूं। शायद यह ~ 50 बाइट्स दस्तक देगा।

— कारजेनिकट

Answer 12

क्लोजर, 253 बाइट्स

(defmacro q[& a] `(with-precision ~@a))(defn h[n](nth(str(reduce +(map #(let[p(+(* n 2)1)a(q p(/ 1M(.pow 16M %)))b(q p(/ 4M(+(* 8 %)1)))c(q p(/ 2M(+(* 8 %)4)))d(q p(/ 1M(+(* 8 %)5)))e(q p(/ 1M(+(* 8 %)6)))](* a(-(-(- b c)d)e)))(range(+ n 9)))))(+ n 2)))

इस सूत्र का उपयोग करके संख्या पाई की गणना करें । with-precisionइसे बार-बार उपयोग करने के कारण मैक्रो को फिर से परिभाषित करना है ।

आप यहाँ आउटपुट देख सकते हैं: https://ideone.com/AzumC3 1000 और 10000 ideone, shrugs पर इस्तेमाल की गई समय सीमा से अधिक है

Answer 13

पायथन 3 , 338 बाइट्स

यह कार्यान्वयन Chudnovsky एल्गोरिथ्म पर आधारित है , जो कि पी का अनुमान लगाने के लिए सबसे तेज़ एल्गोरिदम में से एक है। प्रत्येक पुनरावृत्ति के लिए, लगभग 14 अंक अनुमानित हैं ( आगे के विवरण के लिए यहां एक नज़र डालें )।

f=lambda n,k=6,m=1,l=13591409,x=1,i=0:not i and(exec('global d;import decimal as d;d.getcontext().prec=%d'%(n+7))or str(426880*d.Decimal(10005).sqrt()/f(n//14+1,k,m,l,x,1))[n+2])or i<n and d.Decimal(((k**3-16*k)*m//i**3)*(l+545140134))/(x*-262537412640768000)+f(n,k+12,(k**3-16*k)*m

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

Answer 14

जावा 7, 262 260 बाइट्स

import java.math.*;int c(int n){BigInteger p,a=p=BigInteger.TEN.pow(10010).multiply(new BigInteger("2"));for(int i=1;a.compareTo(BigInteger.ZERO)>0;p=p.add(a))a=a.multiply(new BigInteger(i+"")).divide(new BigInteger((2*i+++1)+""));return(p+"").charAt(n+1)-48;}

प्रयुक्त @ LeakyNun के अजगर 2 एल्गोरिथ्म ।

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

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

import java.math.*;
class M{
  static int c(int n){
    BigInteger p, a = p = BigInteger.TEN.pow(10010).multiply(new BigInteger("2"));
    for(int i = 1; a.compareTo(BigInteger.ZERO) > 0; p = p.add(a)){
      a = a.multiply(new BigInteger(i+"")).divide(new BigInteger((2 * i++ + 1)+""));
    }
    return (p+"").charAt(n+1) - 48;
  }

  public static void main(String[] a){
    System.out.print(c(0)+", ");
    System.out.print(c(1)+", ");
    System.out.print(c(2)+", ");
    System.out.print(c(3)+", ");
    System.out.print(c(10)+", ");
    System.out.print(c(100)+", ");
    System.out.print(c(599)+", ");
    System.out.print(c(760)+", ");
    System.out.print(c(1000)+", ");
    System.out.print(c(10000));
  }
}

आउटपुट:

1, 4, 1, 5, 8, 8, 2, 4, 3, 5

Answer 15

स्मालटाक - 270 बाइट्स

पहचान पर निर्भर करता है tan⁻¹(x) = x − x³/3 + x⁵/5 − x⁷/7 ..., और वह π = 16⋅tan⁻¹(1/5) − 4⋅tan⁻¹(1/239)। यदि आप प्रतीक्षा करने के लिए तैयार हैं तो छोटे GSM असीमित परिशुद्धता पूर्णांक अंकगणित का उपयोग करता है, इसलिए यह बड़े इनपुट के लिए काम करेगा!

|l a b c d e f g h p t|l:=stdin nextLine asInteger+1. a:=1/5. b:=1/239. c:=a. d:=b. e:=a. f:=b. g:=3. h:=-1. l timesRepeat:[c:=c*a*a. d:=d*b*b. e:=h*c/g+e. f:=h*d/g+f. g:=g+2. h:=0-h]. p:=4*e-f*4. l timesRepeat:[t:=p floor. p:=(p-t)*10]. Transcript show:t printString;cr

के रूप में सहेजें pi.stऔर निम्न परीक्षण मामलों में चलाएं। अनुक्रमण एक आधारित है।

$ gst -q pi.st <<< 1
1
$ gst -q pi.st <<< 2
4
$ gst -q pi.st <<< 3
1
$ gst -q pi.st <<< 4
5
$ gst -q pi.st <<< 11
8
$ gst -q pi.st <<< 101
8
$ gst -q pi.st <<< 600
2
$ gst -q pi.st <<< 761
4
$ gst -q pi.st <<< 1001
3
$ gst -q pi.st <<< 10001 -- wait a long time!
5

Answer 16

जावास्क्रिप्ट (Node.js) (क्रोम 67+), 75 73 67 63 बाइट्स

n=>`${eval(`for(a=c=100n**++n*20n,d=1n;a*=d;)c+=a/=d+++d`)}`[n]

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

$\pi/2=\sum_{k=0}^{\infty}k!/(2k+1)!!$

n=>`${eval(`for(a=c=100n**n*20n,d=1n;a*=d;)c+=a/=d+++d`)}`[n]

जावास्क्रिप्ट (Node.js) (क्रोम 67+), 90 89 बाइट्स

n=>`${eval(`for(a=100n**++n*2n,b=a-a/3n,c=0n,d=1n;w=a+b;a/=-4n,b/=-9n,d+=2n)c+=w/d`)}`[n]

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

$\pi/4=\arctan(1/2)+\arctan(1/3)$

n=>`${eval(`for(a=100n**n*2n,b=a-a/3n,c=0n,d=1n;w=a+b;a/=-4n,b/=-9n,d+=2n)c+=w/d`)}`[n]

Answer 17

मेपल, 24 बाइट्स

 trunc(10^(n+1)*Pi)mod 10

परीक्षण के मामलों:

> f:=n->trunc(10^(n+1)*Pi)mod 10;
> f(0);
  1
> f(1);
  4
> f(2);
  1
> f(3);
  5
> f(10);
  8
> f(100);
  8
> f(599);
  2
> f(760);
  4
> f(1000);
  3
> f(10000);
  5

Answer 18

सी #, 252 250 बाइट्स

d=>{int l=(d+=2)*10/3+2,j=0,i=0;long[]x=new long[l],r=new long[l];for(;j<l;)x[j++]=20;long c,n,e,p=0;for(;i<d;++i){for(j=0,c=0;j<l;c=x[j++]/e*n){n=l-j-1;e=n*2+1;r[j]=(x[j]+=c)%e;}p=x[--l]/10;r[l]=x[l++]%10;for(j=0;j<l;)x[j]=r[j++]*10;}return p%10+1;}

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