Inspiré par cette vidéo de Infinite Series .

introduction

Pi est défini comme le rapport de la circonférence au diamètre d'un cercle. Mais comment définit-on un cercle? Habituellement, un cercle est défini comme les points avec une distance constante au centre (supposons que le centre est à (0,0)). La prochaine question serait: comment définissons-nous la distance ? Dans ce qui suit, nous examinons différentes notions de distances (induites par les Lp-norms):

Étant donné une norme (= quelque chose qui mesure une longueur ), nous pouvons facilement construire une distance (= distance entre deux points) comme suit:

dist(A,B) := norm (A-B)

La norme euclidienne est donnée par:

norm((x,y)) = (x^2 + y^2)^(1/2)

Ceci est aussi appelé la norme L2 . Les autres normes Lp sont construites en remplaçant la 2formule ci-dessus par d'autres valeurs comprises entre 1 et l'infini:

norm_p((x,y)) = (|x|^p + |y|^p)^(1/p)

Les cercles unitaires de ces différentes normes ont des formes bien distinctes:

Défi

Soit a p >= 1, calcule le rapport circonférence / diamètre d'un cercle Lp par rapport à la Lpnorme avec une précision de quatre chiffres significatifs.

Testcases

Nous pouvons utiliser cela car p,qavec 1 = 1/p + 1/qnous obtenons le même ratio pour le Lpaussi bien que pour la Lqnorme. De plus, p = q = 2le ratio est minimal et p = 1, q = infinitynous obtenons un ratio de 4, donc les ratios sont toujours compris entre piet 4.

p   or  q            ratio
1       infinity     4
2       2            3.141592
1.623   2.60513      3.200
1.5     3            3.25976
4       1.33333      3.39693

Python + scipy, 92 octets

from scipy.integrate import*
lambda p:2/p*quad(lambda x:(x/x**p+(1-x)**(1-p))**(1/p),0,1)[0]

La formule est de cette question math.SE .

MATL , 31 octets

0:1e-3:1lyG^-lG/^v!d|G^!slG/^sE

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

Cela génère les coordonnées x , y d'un quart du cercle unitaire échantillonné à 1001 points à l'étape 0.001 dans x . La longueur du quart de cercle est approximée par celle de la ligne polygonale passant par ces points; c'est-à-dire la somme des longueurs des 1000 segments. La longueur est bien sûr calculée en fonction de p-norm. En multipliant le résultat par 2, on obtient la longueur approximative d'un demi-cercle, c'est-à-dire, pi.

0:1e-3:1   % Push [0 0.001 0.002 ... 0.999 1]. These are the x coordinates of
           % the vertices of the polygonal line that will approximate a quarter
           % of the unit circle
l          % Push 1
y          % Duplicate [0 0.001 0.002 ... 0.999 1] onto the top of the stack.
G          % Push input, p
^          % Element-wise power: gives [0^p 0.001^p ... 1^p]
-          % Element-wise subtract from 1: gives [1-0^p 1-0.001^p ... 1-1^p]
lG/        % Push 1, push p, divide: gives 1/p
^          % Element-wise power: gives [(1-0^p)^(1/p) (1-0.001^p)^(1/p) ...
           % ... (1-1^p)^(1/p)]. These are the y coordinates of the vertices
           % of the polygonal line
v          % Concatenate vertically into a 2×1001 matrix. The first row contains
           % the x coordinates and the second row contains the y coordinates
!          % Transpose
d|         % Compute consecutive differences down each column. This gives a
           % 1000×2 matrix with the x and y increments of each segment. These
           % increments will be referred to as Δx, Δy
G          % Push p
^          % Element-wise power
!          % Transpose
s          % Sum of each column. This gives a 1×1000 vector containing
           % (Δx)^p+(Δy)^p for each segment
lG/        % Push 1/p
^          % Element-wise power. This gives a 1×1000 vector containing 
           % ((Δx)^p+(Δy)^p)^(1/p) for each segment, that is, the length of 
           % each segment according to p-norm
s          % Sum the lenghts of all segments. This approximates the length of
           % a quarter of the unit circle
E          % Multiply by 2. This gives the length of half unit circle, that is,
           % pi. Implicitly display

Mathematica, 49 46 octets

^{3 octets enregistrés à cause d' alephalpha .}

2NIntegrate[(1+(a^-#-1)^(1-#))^(1/#),{a,0,1}]&

Fonction anonyme. Prend un nombre en entrée et retourne un nombre en sortie.

PARI / GP, 48 43 octets

C'est facile après que @orlp ait trouvé la formule et que la version de @ alephalpha enregistre 5 octets:

p->2*intnum(u=0,1,(1+(u^-p-1)^(1-p))^(1/p))

Pour ajouter quelque chose de légèrement utile, calculons le ppour lequel on obtient 3.2:

? f=p->2*intnum(u=0,1,(1+(u^-p-1)^(1-p))^(1/p));
? solve(p=1,2,f(p)-3.2)
%2 = 1.623002382384469009676324702

Usage correct

Bien que le code donne des résultats beaucoup plus précis que les exigences du challenge, il peut facilement être beaucoup amélioré: si nous remplaçons la limite d'intégration supérieure 1par [1,1/p-1](en donnant ce que le manuel appelle l'exposant de singularité), tous les chiffres indiqués sont d' f(2)accord Pi. Cela reste vrai si nous augmentons la précision à 100 (type \p100).

Cependant, après ce changement, le solvecalcul ne fonctionnait plus. J'ai changé le terme interne pour gérer explicitement le cas u=0et j'ai également changé pour un ordinateur différent avec une version plus récente de PARI et 64 bits (ce qui implique une précision par défaut plus élevée).

Voici le calcul amélioré de la pvaleur pour Pi=3.2, et regardons aussi le vrai Pi:

? f=p->2*intnum(u=0,[1,1/p-1],if(u,(1+(u^-p-1)^(1-p))^(1/p),0));
? f(2)
%2 = 3.1415926535897932384626433832795028842
? Pi
%3 = 3.1415926535897932384626433832795028842
? solve(p=1,2,f(p)-3.2)
%4 = 1.6230023823844690096763253745604419761

JavaScript (ES7), 80 octets

Basé sur la réponse de orlp . Cette implémentation de JS est assez lente. Vous voudrez peut-être essayer i=1e-7(ou même plus haut) une approximation plus rapide.

Remarque : il s’agit essentiellement de Chrome et Edge uniquement. Une version ES6 équivalente utilisant Math.pow()Firefox 50.1 semble être beaucoup plus lente.

Edit : Selon Neil, cela devrait également fonctionner correctement sur Firefox 52.

f=
p=>{for(i=5e-8,s=x=0;(x+=i)<1;)s+=i*(x**(1-p)+(1-x)**(1-p))**(1/p);return 2/p*s}

console.log(f(1).toFixed(3))
console.log(f(2).toFixed(3))
console.log(f(1.623).toFixed(3))