পাই এর নবম দশমিকটি সন্ধান করুন

Question

ইতিমধ্যে পাইতে উত্সর্গীকৃত 30 টি চ্যালেঞ্জ রয়েছে তবে একটিও আপনাকে নবম দশমিক সন্ধান করতে বলে না, তাই ...

চ্যালেঞ্জ

0 <= n <= 10000প্রদর্শনের ব্যাপ্তির যে কোনও পূর্ণসংখ্যার জন্য পাই এর নবম দশমিক।

বিধি

• দশমিকের পরে প্রতিটি সংখ্যা 3.
• আপনার প্রোগ্রামটি কোনও ফাংশন বা একটি সম্পূর্ণ প্রোগ্রাম হতে পারে
• আপনার ফলাফলটি বেস 10 এ আউটপুট করতে হবে
• আপনি nকোনও উপযুক্ত ইনপুট পদ্ধতি (স্টিডিন, ইনপুট (), ফাংশন প্যারামিটার, ...) থেকে পেতে পারেন, তবে হার্ডকড নয়
• যদি এটি আপনার পছন্দের ভাষার স্থানীয় হয় তবে আপনি 1-ভিত্তিক সূচক ব্যবহার করতে পারেন
• (আপনি অবৈধ ইনপুট সাথে মোকাবিলা করতে হবে না n == -1, n == 'a'বা n == 1.5)
• বিল্টিনগুলি অনুমোদিত হয়, যদি তারা কমপক্ষে 10 কে দশমিক পর্যন্ত সমর্থন করে
• রানটাইম কোনও বিষয় নয় কারণ এটি সবচেয়ে সংক্ষিপ্ত কোড সম্পর্কিত এবং দ্রুততম কোড নয়
• এটি কোড-গল্ফ , বাইট জেতে সংক্ষিপ্ততম কোড

পরীক্ষার মামলা

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

অবগতির জন্য, এখানে পাই এর প্রথম 100 কিলোবাইট ডিজিটের হয়।

Comments

অন্তর্নির্মিত-ইনগুলি? উদাহরণস্বরূপstr(pi())[n+2]

— প্রিমো

আইএমওর নিকটতম ডুপ টার্গেটগুলি হ'ল পাইয়ের ক্ষুদ্র অঙ্কের অঙ্কের শক্তিগুলি (প্যারামিটারকে ওভারলোড করে দেয়, বা এটি কেবল এই চ্যালেঞ্জের সাথে প্রয়োগ করা একটি সীমাবদ্ধ পার্থক্য হবে ), পাইকে সুনির্দিষ্টভাবে প্রেরণ করুন (একটি সূচক যুক্ত করে এবং কিছু মুদ্রণ দমন করে), এবং পাই উইন্ডো এনক্রিপশন ।

— পিটার টেলর

@ সুভার অফ কোর্স! এই নিয়মটি কেবল এটি নির্দেশ করতেই পারে যে আপনার প্রোগ্রামটি হ্যান্ডেল করতে

— 10 মিনিট হ'ল ন্যূনতম

আমি পরীক্ষার ক্ষেত্রে f (599) যুক্ত করার পরামর্শ দিচ্ছি, কারণ এটির ভুল হওয়া সহজ হতে পারে (আপনার প্রায় 3 দশমিক অতিরিক্ত অতিরিক্ত নির্ভুলতা প্রয়োজন)।

— অ্যাডিটসু

এছাড়াও f (760) = 4, যা 4 999999 8 সিকোয়েন্স শুরু হয় , ভুলভাবে গোল করা সহজ।

— অ্যান্ডারস কাসেরগ

Answer 1

05 এ বি 1 ই, 3 বাইট

žs¤

ব্যাখ্যা

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

এটি অনলাইনে চেষ্টা করুন

1-ভিত্তিক সূচক ব্যবহার করে।
100k সংখ্যা পর্যন্ত সমর্থন করে।

Comments

পাই থেকে এন অঙ্কগুলি গোল হয় না?

— বুস্কুকুয়ান

@ বসুকক্সুয়ান নং এটি পাই থেকে 100 কে অঙ্কের পূর্বনির্ধারিত ধ্রুবক ব্যবহার করে এবং এর মধ্যে এন উদ্ধার করে।

— এমিগিনা

@ এমিগনা এটি খুব সহজ ভাল সমাধান।

— সোয়েভার

সংক্ষিপ্ত এবং তীক্ষ্ণ, পিসিজি সর্বোত্তম

— জাইলিয়াস

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

অ্যালগোরিদমের মধ্যে এন ব্যবহার সম্পর্কে সতর্কতা অবলম্বন করা আবশ্যক ... 599 জন্য আউটপুট 2 হওয়া উচিত, না 1. এছাড়াও আপনি নির্দিষ্ট করতে আপনি পাইথন 2. ব্যবহার করছেন চাইতে পারেন

— aditsu

@ অ্যাডিটস আপডেট হয়েছে। সমস্ত এন ≤ 1000 এর জন্য নিশ্চিত করা হয়েছে ।

— প্রিমো

আপনি যদি nইনপুট প্লাস 9 হিসাবে গ্রহণ করেন তবে আপনি পেরেনগুলি এড়াতে পারবেন।

— xnor

@ xnor d'oh। ধন্যবাদ;)

— প্রিমো

এই অ্যালগরিদমের দ্বারা উত্পাদিত প্রথম কয়েকটি অঙ্কগুলি হ'ল '' 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 বাইট

thanks to @aditsu for increasing my score by 2 bytes

Finally an algorithm that can complete under 2 seconds.

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 it!

Uses the formula pi = 4*arctan(1) while computing arctan(1) using its taylor series.

Comments

Quite speedy. 1-indexing is not native to python, though. Last I recall (admittedly I've been inactive for a while), consensus was that functions need to be defined, e.g. f=lambda n:....

— primo

Almost every lambda here are anonymous (you can search answers in Python in this site)

— Leaky Nun

Relevant meta post. Seems to be in violation of Rule 1 and 3 (after running your code, there is no way to capture the function reference; the function definition would need to be typed out for each input ((lambda n:`p`[n+1])(1), (lambda n:`p`[n+1])(2), ...).

— primo

You can't run the code directly. It is akin to placing import statements beforehand, just that this makes some global variables beforehand.

— Leaky Nun

i=3 while a:a=i/2*a/i;p+=a;i+=2 for 4.

— primo

Answer 5

MATL, 11 10 bytes

1 byte saved thanks to @Luis

YPiEY$GH+)

This solution utilizes 1-based indexing

Try it Online

All test cases

Explanation

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 Oh yea I guess the output is already a string. Doh!

— Suever

@LuisMendo Oh I never actually thought of that. I always use YP in my testing of the symbolic toolbox

— Suever

ওয়াইপি আসলেই অনুমোদিত? প্রশ্নটি বলছে যে এটি <= 10 কে ডিজিট

— বুসুক্সুয়ান

@ স্যুভার ওপি "কমপক্ষে" না বলে "আপ" লিখেছেন। আমার বোঝার কাছে এর মানে হল যে সমর্থন করা> 10 কে নিষিদ্ধ।

— বুসুক্সুয়ান

@ স্যুভার হ্যাঁ, আমি মনে করি আমি হতে পারি, যেহেতু আমি এটি করতে বাধা দিতে পারি না ol আমি কেবলমাত্র সেজন্য আমার সেজে উত্তরটি মুছলাম।

— বুসুক্সুয়ান

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]

এই জাতীয় ভাষায় আমার প্রথম উত্তর।

npi17775 ডিজিটের রাউন্ডগুলি ।

Comments

আপনার printকল দরকার , নাহলে এটি একটি স্নিপেট যা কেবল আরপিএলে কাজ করে।

— মেগো

This works for (theoretically) any input: lambda d:`n(pi,digits=d+5)`[-4]

— Mego

@Mego there aren't "99999" runs?

— busukxuan

@Mego but then there will be even longer "9" runs. I'm not sure if doubling the length can make it universal, but I think not even that can do it, due to the Infinite Monkey Theorem: en.wikipedia.org/wiki/Infinite_monkey_theorem

— busukxuan

@busukxuan If you model the uncomputed digits of π as random, you certainly expect arbitrarily long runs of 9s (and we have no reason to expect the real π to be any different, though we have not proven this), but you only expect a run of 9s as long as its position with vanishingly small probability (though again, we haven’t proven that the real π doesn’t behave unexpectedly). We have found runs of at least nine 9s, which I think is enough to break the [-8] proposal.

— Anders Kaseorg

Answer 8

CJam, 32

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

Try it online (it's a bit slow)

Answer 9

Mathematica, 23 21 bytes

⌊10^# Pi⌋~Mod~10&

SageMath, 24 bytes

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

Comments

@LLlAMnYP I tried that, but Mathematica seems to require a space between Pi and ⌋ (or between # and ⌋ if the multiplication is flipped), so the saving disappears.

— Anders Kaseorg

Actually it works in the Mathematica Online (I had been using the console version), so I’ll take it, I guess.

— Anders Kaseorg

These should be separate answers. Though they use the same strategy, they are nowhere near the same language.

— Mego

@Mego The policy I found does not say answers in different languages cannot count as very similar. (The answer suggesting that was not accepted.) Are you referring to another policy or just a preference?

— Anders Kaseorg

Answer 10

J, 19 15 bytes

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

Takes an integer n and outputs the n^th digit of pi. Uses zero-based indexing. To get the n^th digit, compute pi times 10ⁿ⁺¹, take the floor of that value, and then take it modulo 10.

Usage

The input is an extended integer.

   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

On my machine, it takes about 18 minutes to compute the 10000^th digit.

Explanation

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

Clojure, 312 bytes

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

So, as you can probably tell, I have no idea what I'm doing. This ended up being more comical than anything. I Google'd "pi to n digits", and ended up on the Wikipedia page for the Bailey–Borwein–Plouffe formula. Knowing just barely enough Calculus(?) to read the formula, I managed to translate it into Clojure.

The translation itself wasn't that difficult. The difficulty came from handling precision up to n-digits, since the formula requires (Math/pow 16 precision); which gets huge really fast. I needed to use BigDecimal everywhere for this to work, which really bloated things up.

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

Needless to say, I'm sure there's an easier way to go about this if you know any math.

(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

I realized later that the standard operators actually work on big decimals, so the shortcuts at the top are unnecessary. I mount fix this at some point. That'll probably knock off ~50 bytes.

— Carcigenicate

Answer 12

Clojure, 253 bytes

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

Calculate number pi using this formula. Have to redefine macro with-precision as it's used too frequently.

You can see the output here: https://ideone.com/AzumC3 1000 and 10000 takes exceeds time limit used on ideone, shrugs

Answer 13

Python 3, 338 bytes

This implementation is based on the Chudnovsky algorithm, one of the fastest algorithms to estimate pi. For each iteration, roughly 14 digits are estimated (take a look here for further details).

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

Try it online!

Answer 14

Java 7, 262 260 bytes

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

Used @LeakyNun's Python 2 algorithm.

Ungolfed & test code:

Try it here.

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

Output:

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

Answer 15

Smalltalk – 270 bytes

Relies on the identity tan⁻¹(x) = x − x³/3 + x⁵/5 − x⁷/7 ..., and that π = 16⋅tan⁻¹(1/5) − 4⋅tan⁻¹(1/239). SmallTalk uses unlimited precision integer arithmetic so it will work for large inputs, if you're willing to wait!

|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

Save as pi.st and run as in the following test cases. Indexing is one based.

$ 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

JavaScript (Node.js) (Chrome 67+), 75 73 67 63 bytes

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

Try it online!

Using $\pi/2=\sum_{k=0}^{\infty}k!/(2k+1)!!$ (same logic used by Leaky Nun's Python answer, but thanks to the syntax of JS that makes this shorter). Input is passed to the function as a BigInt. 2 bytes can be removed if 1-based indexing is used:

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

JavaScript (Node.js) (Chrome 67+), 90 89 bytes

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]

Try it online!

Using $\pi/4=\arctan(1/2)+\arctan(1/3)$. Input is passed to the function as a BigInt. 2 bytes can be removed if 1-based indexing is used:

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

Maple, 24 bytes

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

Test cases:

> 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

C#, 252 250 bytes

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

Try it online!