Pi'yi 5 ondalığa hesapla


15

Bu http://programmers.blogoverflow.com/2012/08/20- tartışmalı-programlama-opinions/ adresinden gelir.

"Pi'nin 4 * (1 - 1/3 + 1/5 - 1/7 +…) fonksiyonu kullanılarak daha fazla doğruluk vererek tahmin edilebileceği göz önüne alındığında, Pi'yi 5 ondalık basamak hassasiyetinde hesaplayan bir fonksiyon yazın. "

  • Tahmin, yukarıda verilen sıra hesaplanarak yapılmalıdır.

8
Muhtemelen daha fazla kural eklemelisiniz, aksi takdirde (python) gibi cevaplar alırsınızp=lambda:3.14159
Matt

1
Çok benzer olan codegolf.stackexchange.com/questions/506/… ' ı gördünüz ? En azından, bu QBASIC programı gibi önemsiz çözümlere izin verdikleri için trig işlevleri bu sorun için yasaklanmalıdır:? INT (4E5 * ATN (1)) / 1E5
Lütfen

Bence algoritmanın ardışık yaklaşımlardan biri olmasını istemelisiniz: ne kadar uzun süre hesaplarsanız, pi'ye o kadar yaklaşırsınız.
DavidC

@DavidCarraher, bu seri kullanılarak matematiksel olarak kaçınılmaz olmasına rağmen, sayısal bir analitik açıdan oldukça şüpheli. Yavaşça birbirine yaklaşan bir dizi seri, önem kaybı için poster çocuğudur.
Peter Taylor

2
Dupe, ama çok eski değil burada: stackoverflow.com/q/407518/12274
JB

Yanıtlar:


10

JavaScript, 46 58 56 45 bayt

ES6 güncellemesi : Beş yıl geçti artık bizim için daha fazla özellik var.

let f=(i=0,a=0)=>i>1e6?a:f(i+4,a+8/-~i/(i+3))

Bu sürüm ( 45 bayt; evet, letgereklidir) teoride ES6 katı modda çalışır . Pratikte, V8'de (örn. Düğüm ile) --use-strict --harmony-tailcalls; Uygun Tailcalls özelliği henüz yaygın olarak uygulanmadı. Ancak, davranış belirtildi, bu yüzden iyi olmalı.

Yaygın olarak uygulananlara sadık kalmak istiyorsak ve katı mod gerektirmiyorsa, ES6 yağ oku sözdizimini işlevler için kullanabiliriz, ancak başka bir şekilde (Brian H tarafından önerilen) 48 baytlık bir maliyetle aynı uygulamayı koruyabiliriz .

a=>{for(a=i=0;i<1e6;a+=8/++i/~-(i+=3));return a}

Tek bir parametre için isim seçimi gerçekten önemli değildir , ancak küresel kapsamdaki kirliliği en aza indirmek için kullandığımız isimlerden birini de seçebiliriz.


function(){for(a=i=0;i<1e6;a+=8/++i/~-(i+=3));return a}

Bu sürüm bir işlev ifadesidir; fadlandırılmasını istiyorsanız iki karakter ekleyin (örneğin " "). Bu versiyon küreselleri gölgeliyor ave i; a,iparametre listesine " " eklersek bu önlenebilir .

Çıkarma ihtiyacını ortadan kaldırmak için algoritmanın yeniden düzenlenmiş bir versiyonunu kullanır.

 1/1 - 1/3  +   1/5 - 1/7   +    1/9 - 1/11  + ...
(3/3 - 1/3) + (7/35 - 5/35) + (11/99 - 9/99) + ...
    2/3     +      2/35     +       2/99     + ...
  2/(1*3)   +    2/(5*7)    +     2/(9*11)   + ...

İşte bu ayar olmadan "düz" bir sürüm:

function(){for(a=0,i=1;i<1e6;i+=2)a+=[,4,,-4][i%4]/i;return a}

hangi 64 62 karakter saat.

Öneri için @ardnew sayesinde kurtulmak için 4*önce return.


Tarih

function(){for(a=i=0;i<1e6;a+=8/++i/~-(i+=3));return a}     // got rid of `i+=4`; restructured
// Old versions below.
function(){for(a=0,i=1;i<1e6;i+=4)a+=8/i/-~-~i;return a}    // got rid of `4*`
function(){for(a=0,i=1;i<1e6;i+=4)a+=2/i/-~-~i;return 4*a}

o Çıkarmayı çarpanlarına ayıran çok güzel bir iş.
acolyte

1
harika bir iş, ama uygun bir işlev olarak yazılması gerekiyor
ardnew

@ardnew: Teşekkürler, sorun açıklamasını okurken bu ayrıntıyı kaçırmış olmalıyım. Ben güncelledim ve şimdi çağrılabilir bir fonksiyon ifadesi (lambda); buna izin verilip verilmediğinden veya bir adın verilmesi gerekip gerekmediğinden emin değilim. Eğer durum buysa, bu sadece iki karakter daha.
FireFly

1
@FireFly da değiştirerek 2 karakter kapalı tıraş edebilirsiniz a+=2/i/-~-~i;return 4*aiçina+=8/i/-~-~i;return a
ardnew

@ardnew: oh, harika; bunu düşünmedim. : D
FireFly

8

Python 59 bayt

print reduce(lambda x,p:p/2*x/p+2*10**999,range(6637,1,-2))

Bu 1000 basamak basar; gerekli olandan biraz daha fazla 5. Öngörülen yinelemeyi kullanmak yerine, bunu kullanır:

pi = 2 + 1/3*(2 + 2/5*(2 + 3/7*(2 + 4/9*(2 + 5/11*(2 + ...)))))

6637(En iç payda) şeklinde formüle edilebilir:

basamak * 2 * günlük 2 (10)

Bu doğrusal bir yakınsama anlamına gelir. Her derin yineleme bir ikili pi daha üretecektir .

Bununla birlikte, tan -1 kimliğinikullanmakta ısrar ederseniz ,sorunu biraz farklı bir şekilde ele almayı düşünmezseniz, benzer bir yakınsama elde edilebilir. Kısmi miktarlara göz atmak:

4.0, 2.66667, 3.46667, 2.89524, 3.33968, 2.97605, 3.28374, ...

her terimin yakınsama noktasının her iki tarafına ileri geri atladığı açıktır; dizinin dönüşümlü yakınsaması var. Ayrıca, her terim yakınsama noktasına bir önceki terimden daha yakındır; yakınsama noktasına göre kesinlikle tekdüzedir. Bu iki özelliğin kombinasyonu, iki komşu terimin aritmetik ortalamasının yakınsama noktasına her iki terimin kendisinden daha yakın olduğu anlamına gelir. Ne demek istediğimle ilgili daha iyi bir fikir vermek için aşağıdaki resmi göz önünde bulundurun:

Partial Sums

Dış seri orijinaldir ve iç seri komşu terimlerin her birinin ortalaması alınarak bulunur. Dikkat çekici bir fark. Ama gerçekten dikkat çekici olan, bu yeni dizinin de alternatif yakınsamaya sahip olması ve yakınsama noktasına göre kesinlikle tekdüze olması. Bu, bu sürecin tekrar tekrar uygulanabileceği anlamına gelir, ad nauseum.

Tamam. Ama nasıl?

Bazı resmi tanımlar. Let p 1 (n) olması , n inci birinci dizisinin terimi p 2 (n) olması , n inci ikinci sekans terimi ve benzer şekilde p k (n) n, inci terimi k inci yukarıda tanımlandığı gibi sekans .

P 1 = [P 1 (1), P 1 (2), P 1 (3), P 1 (4), P 1 (5), ...]

P 2 = [(P 1 (1) + P 1 (2)) / 2, (P 1 (2) + P 1 (3)) / 2, (P 1 (3) + P 1 (4)) / 2, (P 1 (4) + P 1 (5)) / 2, ...]

P 3 = [(P 1 (1) + 2P 1 (2) + P 1 (3)) / 4, (P 1 (2) + 2P 1 (3) + P 1 (4)) / 4, (P 1 (3) + 2P 1 (4) + P 1 (5)) / 4, ...]

P 4 = [(P 1 (1) + 3P 1 (2) + 3P 1 (3) + P 1 (4)) / 8, (P 1 (2) + 3P 1 (3) + 3P 1 (4) + P 1 (5)) / 8, ...]

Şaşırtıcı olmayan bir şekilde, bu katsayılar tam olarak binom katsayılarını takip eder ve Pascal Üçgeni'nin tek bir sırası olarak ifade edilebilir. Pascal Üçgeni'nin rasgele bir sıra hesaplamak için önemsiz olduğu için, bir isteğe bağlı olarak 'derin' serisi bulunabilir, sadece birinci alarak n karşılık gelen terimi ile çarpın her kısmi miktarda, k inci Pascal Triangle satır ve bölünerek 2 k-1 .

Bu şekilde, tam 32 bit kayan nokta hassasiyeti (~ 14 ondalık basamak) yalnızca 36 yineleme ile elde edilebilir, bu noktada kısmi toplamlar ikinci ondalık basamakta bile yakınsamaz. Açıkçası bu golf değil:

# used for pascal's triangle
t = 36; v = 1.0/(1<<t-1); e = 1
# used for the partial sums of pi
p = 4; d = 3; s = -4.0

x = 0
while t:
  t -= 1
  p += s/d; d += 2; s *= -1
  x += p*v
  v = v*t/e; e += 1

print "%.14f"%x

Rastgele bir hassasiyet istiyorsanız, bu küçük bir değişiklikle elde edilebilir. Burada bir kez daha 1000 basamak hesaplanıyor:

# used for pascal's triangle
f = t = 3318; v = 1; e = 1
# used for the partial sums of pi
p = 4096*10**999; d = 3; s = -p

x = 0
while t:
  t -= 1
  p += s/d; d += 2; s *= -1
  x += p*v
  v = v*t/e; e += 1

print x>>f+9

Başlangıç değeri p başlar 2 10 arasında bir tamsayıdır bölme etkilerini ortadan kaldırmak için, daha büyük bir s / d olarak d yakınsama son birkaç basamak neden daha büyük olur. Yine burada 3318da dikkat edin :

basamak * log 2 (10)

İteratations aynı sayıda birinci algoritma (nedeniyle yarıya t azalır 1 yerine 2 her bir tekrar). Bir kez daha, bu doğrusal bir yakınsamayı gösterir: yineleme başına bir ikili bit pi . Her iki durumda da, 5 basamaklı pi hesaplamak için 3318 iterasyon, 5 hesaplamak için 1 milyon iterasyondan biraz daha iyi kota olarak gereklidir .


Bu benim 4 * sum(1/(1+i*2) if not i%2 else -1/(1+i*2) for i in xrange(places*10**(places)))
Aaron Hall

1
Bu, benim farklı bir formunuz olan yaklaşımımla çok benzer . Benimki gibi k → ∞, f(-1,k)Euler-sum'ınıza yaklaşıyor.
Simply Beautiful Art

1
Çok havalı; harika analiz ve açıklama, teşekkür ederim.
jeremy radcliff

Sadece küçük bir şey. Peşinde ifade etmedi P_1 = ..., P_2 = ..., P_3 = ..., P_4 = ..., "... çarpın karşılık gelen her terimin tarafından kthPascal Üçgeni satırınızda ve bölünmesi 2^{k-1}." Yerine nthsatır ve 2^{n-1}?.
jeremy radcliff

@jeremyradcliff Yaptım, evet. Düzeltme için teşekkürler.
primo

5

Mathematica 42 39 34 33 31 26 32

Arşimet Yaklaşımı 26 karakter

N@#*Sin[180 Degree/#]&

Girdi 822 olduğunda bu kritere ulaşır.

Soru: Günah'ı 180 derece nasıl hesapladığını bilen var mı? Yapmıyorum.


Leibniz 'Yaklaşımı (Gregory'nin serisi) 32 karakter

Bu, sorun çözücünün örnek olarak verdiği işlevle aynıdır. Yaklaşık yarım milyon yinelemede kritere ulaşır.

N@4Sum[(-1)^k/(2k+1),{k,0,10^6}]

Madhava-Leibniz Yaklaşımı 37 karakter

Bu varyasyon birkaç karakter daha kullanıyor ancak yalnızca 9 yinelemede ölçütle birleşiyor!

N@Sqrt@12 Sum[(-1/3)^k/(2k+1),{k,0,9}]

hepsi problem tanımında verilen algoritma ile hesaplar?
acolyte

@acolyte Leibniz'in yaklaşımı (şimdi listelenen ilk yaklaşım) gerçekten sorunun tanımında bahsedilen yaklaşımdır. Yakınsama çok yavaş. Üzerinde küçük bir varyasyon (Madhava-Leibniz) çok hızlı bir şekilde birleşir.
DavidC

180 ° sinüs oldukça kolaydır. N için olağan şüphelilerin dışında zorlaşabilen 180 ° / N
JB

Lütfen açıklayın, @JB Ölçmek zor?
DavidC

Bu girdi "32" yi belirtmelidir, çünkü sadece Leibniz'in yaklaşımı gereksinimleri karşılar (koddaki karakterleri verilen şekilde sayarak 34 alırım, ancak her iki boşluk da güvenle kaldırılabilir ve gerçekten de 32 uzunluk verir).
celtschk


4

Java (67 karakter)

float r(){float p=0,s=4,i=1E6f;while(--i>0)p+=(s=-s)/i--;return p;}

Bunun, sayıları doğru sırada ekleyerek önem kaybını önlediğini unutmayın.


bu da tamamen uyumlu C kodudur. C yayınlanmıştır, sen değişebilir while(--i>0)için while(i--)ve 2 karakter kurtarmak
ardnew

1
@ardnew, true, ama C ile oynamak için çok daha ilginç hileler var ...
Peter Taylor

4

Haskell, 32

foldr(\k->(4/(2*k+1)-))0[0..8^7]

GHCi> foldr (\ k -> (4 / (2 * k + 1) -)) 0 [0..8 ^ 7]
3.141593130426724

İşlev adını saymak

34

π=foldr(\k->(4/(2*k+1)-))0[0..8^7]


3

C (GCC) (44 karakter)

float p(i){return i<1E6?4./++i-p(++i):0;}

Bu 41 karakterdir, ancak -O2kuyruk özyinelemesini ortadan kaldırmak için iyileştiriciyi elde etmek için de derlenmelidir . Bu aynı zamanda,++ , yürütülme ; ugoren'e bunu işaret ettiği için teşekkürler. 64 bit Linux altında gcc 4.4.3 ile test yaptım.

Optimize edici aynı zamanda toplamı yeniden sıralamazsa, en küçük sayıdan ekleneceğini unutmayın, bu nedenle önem kaybını önler.

Olarak arayın p().


Özyinelemeli çağrınız q()değil p(). Ve -O2sayılmaması gerektiğini düşünmüyorum (ancak sayıyorsanız, gerekli alan nedeniyle 4 karakter).
ugoren

Ayrıca: 1. gcc 4.1.1 özyinelemeyi optimize etmez (ve nasıl olabilir görmüyorum), bu nedenle yığın taşar. 2. olarak adlandırılmalıdır p(0). 3. Bir karakteri kaydedin return++i.... 4. İki ++itanımsız davranış yapar.
ugoren

@ugoren, yorumlarınız için teşekkürler. Sırayla: q- bu, yeniden adlandırdıktan sonra tekrar kontrol etmemi öğretecek. -O23 karakter olarak sayma normal uygulama takip düşünüyorum , ama isterseniz meta açabilirsiniz; meta.codegolf.stackexchange.com/questions/19 bulabildiğim tek alakalı tartışma. Kullandığım gcc sürümünü ekledim ve bu da onu aramamı sağlıyor p(). Karakterleri kaydetmek, optimizasyonu durdurur ve segfault verir. Ben meta.codegolf.stackexchange.com/questions/21
Peter Taylor

Bayraklarla ilgili meta soruya bir cevap ekledim. Hakkında p()- p()herhangi bir bağlamdan aramanın işe yarayacağından emin misiniz ? Yoksa sadece testinizde yığında ne oldu?
ugoren

@ugoren, belki de sürekli şanslıyım. Arka arkaya iki kez çağırsam bile, ikincisi hala doğru değeri döndürür. gcc p()vs için biraz farklı kod üretiyor gibi görünüyor p(0), ancak hangi davranışı belgelediğini bilmiyorum ve gerçekten bir C programcısı değilim.
Peter Taylor

3

J, 26 karakter

+ / + / _ 2 ((4 _4) ve%)>: +: i.100

100 dizi öğeden 1e6 öğeye taşındı. Ayrıca şimdi bir kod etiketli ve tarayıcıdan konsola hatasız kopyalanabilir.

+/+/_2((4 _4)&%)\>:+:i.1e6

3
-/4%>:2*i.1e6- 13 karakter. (#Jsoftware'deki b_jonas sayesinde -/, alternatif işaretli bir toplamı hesaplamak için işe yaradığını anladığım için teşekkürler . [Bu, J'deki tüm işleçlerin eşit önceliğe ve sağ ilişkilendiriciye sahip olması nedeniyle, -/ 1 2 3 4<=> 1 - (2 - (3 - 4))<=> 1 - 2 + 3 - 4.))
FireFly

temiz ve iki kat daha harika. Ya da 2 ^ 10 daha harika!
fftw

@FireFly bu güzel
Jonah

2

Javascript - 33 Karakter

p=x=>4*(1-(x&2))/x+(x>1?p(x-2):0)

pPozitif bir tek sayı geçerek çağırın xve Pi (x-1)/2terimlerini hesaplar .


2

Yakut - 82 karakter

def f(n,k=n)k>0?(f(n,k-1)+f(n+1,k-1))/2:n<0?0:f(n-1,0)+(-1)**n/(2*n+1.0)end;4*f(9)

Deneyin: https://repl.it/LQ8w

Yaklaşım verilen seriyi sayısal bir ivme yaklaşımı kullanarak dolaylı olarak kullanır. Ortaya çıkan çıktı

pi ≈ 3.14159265161

vs.

pi = 3.14159265359

İle başlar

f(n,0) = 1/1 - 1/3 + 1/5 - ... + ((-1)**n)/(2*n+1)

Ve sonra, bu dönüşümlü olduğundan, yakınsama hızını kullanarak

f(n,1) = (f(n,0) + f(n+1,0))/2

Ve bunu tekrar tekrar uygular:

f(n,k) = (f(n,k-1) + f(n+1,k-1))/2

Ve basitlik için f(n) = f(n,n).


Yakut - 50 karakter

Çok uzun bir süre koşmayı önemsemiyorsanız,

def f(n)n<0?0:f(n-1)+(-1)**n/(2*n+1.0)end;4*f(1e7)

veya

a=0;for k in 0..1e7 do a+=(-1)**k/(2*k+1.0)end;4*a

1

C, 69 karakter

float p,b;void main(a){b++<9e6?p+=a/b++,main(-a):printf("%f\n",4*p);}
  • Komut satırı parametresi olmadan çalıştırın ( a1'e sıfırlanır).
  • Optimizasyon ile derlenmelidir.
  • void maingarip ve standart dışıdır, ancak işleri işler hale getirir. Onsuz, özyineleme gerçek bir çağrı olarak uygulanır ve yığın taşmasına neden olur. Bir alternatif eklemek return.
  • 4*Üç komut satırı parametresiyle çalışıyorsa iki karakter kaydedilebilir.

Bunu kısaltabilirsiniz, int main(a)hatta main(a)GCC sadece bir uyarı verir. Her void mainneyse, ve belki de sadece bir argümanınız olduğu için bir uyarı verecektir main.
nyuszika7h

1

Clojure - 79 karakter

(fn [](* 4(apply +(map #(*(Math/pow -1 %1)(/ 1.0(+ 1 %1 %1)))(range 377000)))))

Bu, pi'yi beş ondalık basamağa doğru yaklaştıran bir kayan noktalı sayı hesaplayacak bağımsız değişken olmayan bir işlev oluşturur. Bunun işlevi gibi bir ada bağlamadığını unutmayın, bu pinedenle bu kod ya bir adla yerinde ya da ona bağlı evalolarak değerlendirilmelidir (<code>), bu durumda çözüm

(defn p[](* 4(apply +(map #(*(Math/pow -1 %1)(/ 1.0(+ 1 %1 %1)))(range 377000)))))

82 karakter için

hakkında

(defn nth-term-of-pi [n] (* (Math/pow -1 n) (/ 1.0 (+ 1 n n))))
(defn pi [c] (* 4 (apply + (map nth-term-of-pi (range c)))))
(def  pi-accuracy-constant (loop [c 1000] (if (< (pi c) 3.14159) (recur (inc c)) c)))
; (pi pi-accuracy-constant) is then the value of pi to the accuracy of five decimal places

1

PHP - 56 55 karakter

<?for($j=$i=-1;1e6>$j;){$p+=($i=-$i)/($j+=2);}echo$p*4;

Algoritma kuralını bozmadan çok daha küçük olabileceğimi bilmiyorum.


1
45 yaşına ne dersin? <?for(;1e6>$j;)$p+=($i=-$i|4)/~-$j+=2;echo$p;
primo

Ben bunu bulmaya çalışıyordum, ama bitsel op'ları çalıştıramadım. Önerin için teşekkürler!
TwoScoopsofPig

1 karakteri kaydetmek için son noktalı virgülü kaldırabilirsiniz.
nyuszika7h

1

Perl - 43 39 karakter

anonim altprogramlardaki kurallardan emin değilim, ancak @ FireFly'nin seri yapısını kullanan başka bir uygulama

sub{$s+=8/((4*$_+2)**2-1)for 0..1e6;$s}

sub p{$s+=(-1)**$_*4/(2*$_+1)for 0..1e6;$s}


0

Java - 92 84 karakter

Peter Taylor'ın sonucunu açık bir şekilde yenemem, ama işte benim:

double d(){float n=0,k=0,x;while(n<9E5){x=1/(1+2*n++);k+=(n%2==0)?-x:x;}return 4*k;}

Ungolfed sürümü:

double d() {
    float n = 0, k = 0, x;
    while (n < 9E5) {
        x = 1 / (1 + 2 * n++);
        k += (n % 2 == 0) ? -x : x;
    }
    return 4 * k;
}

Düzenle: Üçlü operatör kullanarak birkaç karakter kaydedildi.


0

Python - 56 karakter

Meh, python-fu'm yeterince güçlü değil. Daha fazla kısayol göremedim ama belki daha deneyimli bir golfçü burada düzeltmek için bir şeyler bulabilir mi?

t=s=0
k=i=1
while t<1e6:t,s,i,k=t+1,k*4./i+s,i+2,-k

Şamandıra bölümü için bir bayt kaydetmek için Python 3'ü kullanabilirsiniz ( 4.-> 4). Diğer yandan, Python 3'ün aslında Python 2'yi kod golfünde geçtiği bir dava buldum!
nyuszika7h

0

Ruby - 54 karakter

def a()p=0;1000000.times{|i|p+=8/(4*i*(4*i+2))};p;end;

Konsolda ilk denemem

def a()i=1;p=0;while i<2**100 do p+=8/(i*(i+2));i+=4;end;p;end;

63 karakter.


Sen kullanarak bir bayt kaydedebilirsiniz def a;yerine def a().
nyuszika7h

Başka bir son noktalı virgül kaldırarak.
nyuszika7h

0

Perl (76 karakter)

$y=1e4;for$x(0..1e4-1){$y--while sqrt($x**2+$y**2)>1e4;$a+=$y}print 4*$a/1e8

(Sonuç: 3.14159052)

Mümkün olan en kısa çözüm değil, belki de ilginç. Geometrik olanı. Bir dairenin altındaki alanı hesaplıyorum.

Başka bir komik yaklaşımım var, ama gerçekten yavaş. Bir karedeki çeyrek dairenin altındaki ayrı noktaların sayısını sayar ve ondan pi hesaplar:

$i=shift;for$x(0..$i){for$y(0..$i){$h++if sqrt($x**2+$y**2)<$i}}print$h*4/$i**2

Yineleme sayısını komut satırı argümanı olarak bekler. Burada çalışma süresinin doğrulukla nasıl ilişkili olduğunu görebilirsiniz. ;)

$ time perl -e '$i=shift;for$x(0..$i){for$y(0..$i){$h++if sqrt($x**2+$y**2)<$i}}print$h*4/$i**2' 100
3.1796
real    0m0.011s
user    0m0.005s
sys 0m0.003s

$ time perl -e '$i=shift;for$x(0..$i){for$y(0..$i){$h++if sqrt($x**2+$y**2)<$i}}print$h*4/$i**2' 1000
3.14552
real    0m0.354s
user    0m0.340s
sys 0m0.004s

$ time perl -e '$i=shift;for$x(0..$i){for$y(0..$i){$h++if sqrt($x**2+$y**2)<$i}}print$h*4/$i**2' 10000
3.14199016
real    0m34.941s
user    0m33.757s
sys 0m0.097s

0

k (25 karakter)

4 * + /% (i # 1 -1) '1 + 2 ! İ: 1000000

Biraz daha kısa:

+/(i#4 -4)%1+2*!i:1000000

0

Python (49)

print 4*sum((-1)**i/(2*i+1.)for i in range(9**6))
3.14159453527



0

SQL, 253 bytes

DECLARE @B int=3, @A varchar(max), @C varchar(max)='1'
WHILE @B<100000
BEGIN
SELECT @C=@C+(select case when (@B-1)%4=0 then'+'else'-'end)+
(SELECT cast(cast(1.0/@B as decimal(9,8)) as varchar(max)))
SELECT @B=@B+2
END
EXECUTE('SELECT 4*('+@C+')')

I would provide a SQL Fiddle, but this goes too many loops deep finding the 1/3 1/5 1/7 etc. fractions and gives errors lol. However, if you change @B<100000 to 1000 then it runs (obviously not to the same number of digits of accuracy).


0

Befunge, 129 bytes

p08p109p^v*86%+55:<$$$<
\$\>:#,_@>+\55+/:#^_"."
v>p"~"/:"~"%08p"~"/00p:2\4%-*"(}"
8^90%"~":+2:+g90*+g80*<
>*:**\/+>"~~"00g:"~"`!|

Try it online!

In case anyone is wondering, it's an elephant.

Cartoon elephant

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.