Znajdź n-ty po przecinku liczby pi

33

Jest już 30 wyzwań poświęconych pi, ale żaden nie prosi o znalezienie n-tego miejsca po przecinku, więc ...

Wyzwanie

Dla dowolnej liczby całkowitej w zakresie 0 <= n <= 10000wyświetlania n-ta liczba dziesiętna liczby pi.

Zasady

  • Po przecinku są kolejne liczby 3.
  • Twój program może być funkcją lub pełnym programem
  • Musisz podać wynik w bazie 10
  • Możesz uzyskać nz dowolnej odpowiedniej metody wprowadzania danych (standardowe wejście, wejście (), parametry funkcji, ...), ale nie zakodowane na stałe
  • Możesz użyć indeksowania opartego na 1, jeśli jest to język ojczysty dla twojego wybranego języka
  • Nie masz do czynienia z nieprawidłowym wejścia ( n == -1, n == 'a'lub n == 1.5)
  • Wbudowane są dozwolone, jeśli obsługują co najmniej 10 000 miejsc po przecinku
  • Środowisko wykonawcze nie ma znaczenia, ponieważ dotyczy ono najkrótszego kodu, a nie najszybszego kodu
  • To jest , wygrywa najkrótszy kod w bajtach

Przypadki testowe

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

Dla odniesienia, oto pierwsze 100k cyfr liczby pi.

Bassdrop Cumberwubwubwub
źródło
Wbudowane? np.str(pi())[n+2]
primo
6
Najbliższe docelowe duplikaty IMO to Obliczanie skróconych sum cyfr mocy pi (przeciąża parametr, lub byłaby to tylko skończona różnica zastosowana do tego wyzwania), Transmit pi precyzyjnie (dodaje indeks i pomija pewne drukowanie) oraz szyfrowanie okna Pi .
Peter Taylor
3
@Suever ofcourse! Ta zasada ma na celu jedynie wskazanie, że 10 000 to minimum, które Twój program powinien być w stanie obsłużyć
Bassdrop Cumberwubwubwub
4
Sugeruję dodanie f (599) do przypadków testowych, ponieważ może być łatwo go pomylić (potrzebujesz około 3 miejsc po przecinku).
aditsu
2
Również f (760) = 4, który rozpoczyna sekwencję 4 999999 8, łatwo zaokrąglić niepoprawnie.
Anders Kaseorg,

Odpowiedzi:

22

05AB1E, 3 bajty

žs¤

Wyjaśnił

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

Wypróbuj online

Wykorzystuje indeksowanie 1.
Obsługuje do 100 000 cyfr.

Emigna
źródło
Cyfry od pi do n nie zaokrąglają się?
busukxuan
7
@busukxuan Nie. Użył predefiniowanej stałej liczby pi do 100k cyfr i pobiera N z nich.
Emigna
4
@Emigna To jest bardzo przydatne. Dobre rozwiązanie.
Suever,
2
Krótko i ostro, PCG w najlepszym
wydaniu
16

Python 2, 66 bajtów

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

Dane wejściowe są pobierane ze standardowego wejścia.


Przykładowe użycie

$ 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
primo
źródło
Uważaj, aby użyć n w algorytmie ... wyjście dla 599 powinno wynosić 2, a nie 1. Możesz także określić, że używasz python 2.
aditsu
@aditsu zaktualizowane. Potwierdzono dla wszystkich n ≤ 1000 .
primo
1
Jeśli weźmiesz nwartość wejściową plus 9, możesz uniknąć parens.
xnor
@xnor d'oh. Dzięki;)
primo
2
Pierwsze kilka cyfr wygenerowanych przez ten algorytm to „3.141596535897932…”, w których brakuje „2” między miejscami 5 i 6. Dlaczego? Ponieważ właśnie wtedy operator Pythona 2 `` zaczyna dołączać Lciąg do.
Anders Kaseorg,
11

Bash + coreutils, 60 49 bajtów

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

Ulepszony przez Dennisa . Dzięki!

Indeks jest oparty na jednym.

Marco
źródło
11

Python 2, 73 71 73 bajtów

dzięki @aditsu za zwiększenie mojego wyniku o 2 bajty

Na koniec algorytm, który można wykonać w ciągu 2 sekund.

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

Korzysta z formuły pi = 4*arctan(1)podczas obliczeń arctan(1)za pomocą serii Taylor.

Leaky Nun
źródło
Całkiem szybko. Jednak indeksowanie 1 nie jest rodzime dla języka Python. Ostatnio pamiętam (co prawda byłem przez jakiś czas nieaktywny), zgoda była taka, że ​​funkcje należy zdefiniować np f=lambda n:....
primo
2
Prawie każda lambda tutaj jest anonimowa (możesz wyszukiwać odpowiedzi w Pythonie na tej stronie)
Leaky Nun
Odpowiedni meta post . Wydaje się być sprzeczne z zasadą 1 i 3 (po uruchomieniu kodu, nie ma sposobu, aby uchwycić odniesienie funkcyjnego; definicja funkcji musiałby być napisany dla każdego wejścia ( (lambda n:`p`[n+1])(1), (lambda n:`p`[n+1])(2)...).
primo
1
Nie możesz uruchomić kodu bezpośrednio. Jest to podobne do importwcześniejszego umieszczania instrukcji, tyle że wcześniej tworzy to niektóre zmienne globalne.
Leaky Nun
i=3 while a:a=i/2*a/i;p+=a;i+=2za 4.
primo
7

MATL, 11 10 bajtów

1 bajt zapisany dzięki @Luis

YPiEY$GH+)

To rozwiązanie wykorzystuje indeksowanie 1

Wypróbuj online

Wszystkie przypadki testowe

Wyjaśnienie

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
Suever
źródło
@LuisMendo O tak, chyba wynik jest już ciągiem. Doh!
Suever
@LuisMendo Och, tak naprawdę nigdy o tym nie myślałem. Zawsze używam YPdo testowania symbolicznego
zestawu
Czy YP faktycznie jest dozwolone? Pytanie mówi, że jest dozwolone, jeśli obsługuje <= 10
000
@Suever OP stwierdził „do” zamiast „przynajmniej”. Według mnie oznacza to, że wsparcie> 10k jest zabronione.
busukxuan
@Suver Tak, myślę, że mogę, bo nie mogę się powstrzymać przed zrobieniem tego lol. Właśnie dlatego usunąłem odpowiedź Sage.
busukxuan
6

Mathematica 30 bajtów

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

DavidC
źródło
5

Sage, 32 25 bajtów

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

Moja pierwsza odpowiedź w języku tego rodzaju.

nzaokrągla pido 17775 cyfr.

busukxuan
źródło
1
Potrzebujesz printpołączenia, w przeciwnym razie jest to fragment kodu, który działa tylko w REPL.
Mego
Działa to (teoretycznie) dla każdego wejścia:lambda d:`n(pi,digits=d+5)`[-4]
Mego
2
@Mego nie ma uruchomień „99999”?
busukxuan
1
@Mego, ale wtedy będzie jeszcze więcej „9” biegów. Nie jestem pewien, czy podwojenie długości może uczynić go uniwersalnym, ale myślę, że nawet to nie może tego zrobić, ze względu na twierdzenie o nieskończonej
małpce
1
@busukxuan Jeśli modelujesz nieobliczone cyfry π jako przypadkowe, na pewno spodziewasz się arbitralnie długich serii 9s (i nie mamy powodu, aby oczekiwać, że rzeczywisty π będzie inny, chociaż tego nie udowodniliśmy), ale oczekujesz tylko bieg 9s, dopóki jego pozycja z znikomym prawdopodobieństwem (choć znowu nie udowodniliśmy, że prawdziwy π nie zachowuje się niespodziewanie). Znaleźliśmy serie co najmniej dziewięciu 9, co moim zdaniem wystarczy, by złamać [-8]wniosek.
Anders Kaseorg,
4

CJam, 32

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

Wypróbuj online (jest trochę powolny)

aditsu
źródło
4

Mathematica, 23 21 bajtów

⌊10^# Pi⌋~Mod~10&

SageMath, 24 bajty

lambda n:int(10^n*pi)%10
Anders Kaseorg
źródło
@LLlAMnYP Próbowałem tego, ale Mathematica wydaje się wymagać spacji między Pii (lub pomiędzy #i jeśli odwrócenie mnożenia jest odwrócone), więc zapisywanie znika.
Anders Kaseorg,
Właściwie to działa w Mathematica Online (korzystałem z wersji konsolowej), więc chyba to wezmę.
Anders Kaseorg,
4
To powinny być osobne odpowiedzi. Chociaż używają tej samej strategii, nie są w pobliżu tego samego języka.
Mego
@Mego Znalezione przeze mnie zasady nie mówią, że odpowiedzi w różnych językach nie mogą być liczone jako bardzo podobne. (Odpowiedź sugerująca, że ​​nie została zaakceptowana.) Czy odwołujesz się do innej polityki, czy po prostu preferencji?
Anders Kaseorg,
3

J , 19 15 bajtów

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

Pobiera liczbę całkowitą n i wyświetla n- cyfrę pi. Używa indeksowania zerowego. Aby uzyskać n- cyfrę, oblicz pi razy 10 n +1 , weź dolną część tej wartości, a następnie weź ją modulo 10.

Stosowanie

Dane wejściowe to rozszerzona liczba całkowita.

   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

Na moim komputerze obliczenie 10000- tej cyfry zajmuje około 18 minut .

Wyjaśnienie

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
mile
źródło
3

Clojure, 312 bajtów

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

Więc, jak zapewne możesz powiedzieć, nie mam pojęcia, co robię. Ostatecznie było to bardziej komiczne niż cokolwiek innego. Zrobiłem Google „pi to n cyfry” i znalazłem się na stronie Wikipedii dla formuły Bailey – Borwein – Plouffe . Znając zaledwie ledwie rachunku różniczkowego (?) Do odczytania wzoru, udało mi się przetłumaczyć go na Clojure.

Samo tłumaczenie nie było takie trudne. Trudność wynikała z obsługi precyzji do n-cyfr, ponieważ wymaga tego wzór (Math/pow 16 precision); który staje się ogromny naprawdę szybko. Musiałem użyć BigDecimalwszędzie, aby to zadziałało, co naprawdę rozłożyło rzeczy.

Nie golfowany:

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

Nie trzeba dodawać, że jestem pewien, że istnieje łatwiejszy sposób na zrobienie tego, jeśli znasz matematykę.

(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])
Carcigenicate
źródło
Później zdałem sobie sprawę, że operatorzy standardowi faktycznie pracują na dużych liczbach dziesiętnych, więc skróty u góry są niepotrzebne. Zamontowałem to naprawić w pewnym momencie. To prawdopodobnie znokautuje ~ 50 bajtów.
Carcigenicate
2

Clojure, 253 bajty

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

Oblicz liczbę pi za pomocą tego wzoru . Muszę przedefiniować makro, with-precisionponieważ jest używane zbyt często.

Możesz zobaczyć wynik tutaj: https://ideone.com/AzumC3 1000 i 10000 trwa przekracza limit czasowy stosowany na ideone, wzrusza ramionami

Cliffroot
źródło
2

Python 3 , 338 bajtów

Ta implementacja oparta jest na algorytmie Chudnovsky'ego , jednym z najszybszych algorytmów do oszacowania pi. Dla każdej iteracji szacuje się około 14 cyfr ( więcej szczegółów znajdziesz tutaj ).

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

Wypróbuj online!

PieCot
źródło
1

Java 7, 262 260 bajtów

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

Używane @ LeakyNun za Python 2 algorytmu .

Kod niepoznany i testowy:

Wypróbuj tutaj.

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

Wydajność:

1, 4, 1, 5, 8, 8, 2, 4, 3, 5
Kevin Cruijssen
źródło
1

Smalltalk - 270 bajtów

Polega na tożsamości tan⁻¹(x) = x − x³/3 + x⁵/5 − x⁷/7 ...i to π = 16⋅tan⁻¹(1/5) − 4⋅tan⁻¹(1/239). SmallTalk korzysta z nielimitowanej arytmetyki liczb całkowitych, więc będzie działał na dużych wejściach, jeśli zechcesz czekać!

|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

Zapisz jako pi.sti uruchom jak w poniższych przypadkach testowych. Indeksowanie opiera się na jednym.

$ 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

źródło
1

JavaScript (Node.js) (Chrome 67+), 75 73 67 63 bajtów

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

Wypróbuj online!

Za pomocą π/2)=k=0k!/(2)k+1)!!(ta sama logika, której używa odpowiedź Leaky Nun w Pythonie, ale dzięki składni JS, która czyni to krótszym). Dane wejściowe są przekazywane do funkcji jako BigInt. 2 bajty można usunąć, jeśli stosowane jest indeksowanie 1:

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

JavaScript (Node.js) (Chrome 67+), 90 89 bajtów

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]

Wypróbuj online!

Za pomocą π/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]
Shieru Asakoto
źródło
0

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
DSkoog
źródło
0

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!

TheLethalCoder
źródło