La constante de Brun est la valeur à laquelle la somme des inverses des paires principales jumelles ( 1/pet 1/(p+2)où pet p+2sont les deux premiers) converge. C'est approximativement 1.902160583104.

Étant donné un nombre entier positif N, approximer la constante de Brun en additionnant les inverses des paires principales jumelles où les deux nombres premiers de la paire sont inférieurs à N, et produire l'approximation.

Règles

• N sera un entier positif dans la plage représentable de votre langue.
• La sortie doit être aussi précise que possible à la valeur réelle, dans les limites de l'implémentation en virgule flottante de votre langue, en ignorant les problèmes potentiels dus aux inexactitudes arithmétiques en virgule flottante. Si votre langage est capable d'arithmétique à précision arbitraire, il doit être au moins aussi précis que l'arithmétique à double précision IEEE 754.
• Alternativement, une fraction exacte peut être sortie dans n'importe quel format cohérent et non ambigu.
• Si un nombre premier apparaît dans plusieurs paires de nombres premiers jumeaux (par exemple 5, une partie des deux (3, 5)et (5, 7)), sa réciproque contribue à la somme à chaque fois.

Cas de test

2 -> 0
6 -> 0.5333333333333333
10 -> 0.8761904761904762
13 -> 0.8761904761904762
100 -> 1.3309903657190867
620 -> 1.4999706034568274
100000 -> 1.67279958482774

Python 3 , 78 77 75 70 68 62 octets

f=lambda n,k=3,m=1,j=0:k<n and-m%k*j*2/k+f(n,k+2,m*k**4,m%k/k)

Merci à @xnor d'avoir joué au golf sur 2 4 octets et ouvert la voie à 4 autres!

Essayez-le en ligne!

Contexte

Rappelons que le théorème de Wilson déclare que pour tous les entiers k> 1 ,

où a ≡ b (mod d) signifie que a - b est divisible par d , c'est-à-dire que a et b ont le même résidu lorsqu'ils sont divisés par d .

Dans Wilson Theorems for Double-, Hyper-, Sub- and Super-factorials , les auteurs prouvent des généralisations pour les doubles factorielles, sur lesquelles cette réponse s'appuie. le double factorielle d'un entier k ≥ 0 est définie par

Le théorème 4 du document susmentionné énonce ce qui suit.

En élevant les deux côtés des congruences à la quatrième puissance, nous déduisons que

pour tous les nombres premiers impairs p . Depuis 1 !! = 1 , l'équivalence vaut également pour p = 2 .

Maintenant, faire la même chose avec le théorème de Wilson révèle que

Puisque

il s'ensuit que

n'importe quand p est premier.

Maintenant, soit k un entier composite impair et positif. Par définition, il existe des entiers a, b> 1 tels que k = ab .

Puisque k est impair, a et b aussi . Ainsi, les deux se produisent dans la séquence 1, 3,…, k - 2 et

où | indique la divisibilité.

En résumé, pour tous les entiers impairs k> 1

où p (k) = 1 si k est premier et p (k) = 0 si k est composite.

Comment ça marche

Lorsque la fonction f est appelée avec un seul argument, k , m et j sont initialisés comme 3 , 1 et 0 .

Notez que ((k - 2) !!) ⁴ = 1 !! ⁴ = 1 = m . En fait, l'égalité m = ((k - 2) !!) ⁴ tiendra à tout moment. j est un flottant et sera toujours égal à ((k - 4) !!) ⁴ % (k - 2) / (k - 2) .

Alors que k <n , le bon argument de andsera évalué. Puisque j = ((k - 4) !!) ⁴ % (k - 2) / (k - 2) , comme prouvé dans le premier paragraphe, j = 1 / (k - 2) si k - 2 est premier et j = 0 sinon. De même, puisque m% k = ((k - 2) !!) ⁴ est égal à 1 si k est premier et 0 sinon, -m% k = k - 1 si k est premier et -m% k = 0 sinon. Par conséquent, est -m%k*j*2/kévalué à 2 (k - 1) / (k (k - 2)) = ((k - 2) + k) / (k (k - 2)) = 1 / k + 1 / (k - 2) si la paire (k - 2, k)se compose de nombres premiers jumeaux et à 0 sinon.

Après avoir calculé ce qui précède, nous ajoutons le résultat à la valeur de retour de l'appel récursif f(n,k+2,m*k**4,m%k/k). k est incrémenté de 2 donc il ne prend que des valeurs impaires ^{‡ †} , nous multiplions m par k ⁴ puisque mk ⁴ = ((k - 2) !!) ⁴ k ⁴ = (k !!) ⁴ , et passons la valeur actuelle m% k / k - qui est égal à 1 / k si le "vieux" k est un nombre premier et 0 sinon - comme paramètre j à l'appel de fonction.

Enfin, une fois que k est égal ou supérieur à n , f renvoie False et la récursivité s'arrête. La valeur de retour de f (n) sera la somme de tous les 1 / k + 1 / (k - 2) tels que (k - 2, k) est une paire principale jumelle et k <n , comme souhaité.

^‡ _{Les résultats du paragraphe Contexte ne s'appliquent qu'aux entiers impairs. Étant donné que même les entiers ne peuvent pas être des nombres premiers jumeaux, nous pouvons les ignorer en toute sécurité.}

Gelée , 15 14 octets

’ÆRµ_2fµ+2;µİS

Essayez-le en ligne!

Comment ça marche

’ÆRµ_2fµ+2;µİS  Main link. Argument: n

’               Decrement; yield n-1.
 ÆR             Prime range; yield all primes in [1, ..., n-1].
   µ            New chain. Argument: r (prime range)
    _2          Subtract 2 from all primes.
      f         Filter; keep all p-2 that appear in r.
       µ        New chain. Argument: t (filtered range)
        +2      Add 2 to all primes in s.
          ;     Concatenate with s.
           µ    New chain. Argument: t (twin primes)
            İ   Take the inverses.
             S  Sum.

Gelée , 16 14 octets (avec un peu d'aide de @Dennis)

’ÆRṡ2_/2+$$ÐḟFİS

Essayez-le en ligne!

En essayant d'améliorer ma réponse précédente, j'ai pensé à un algorithme totalement différent, et il est un peu plus court. J'utilise un article différent pour cela, comme c'est la norme ici pour une réponse qui utilise une technique différente.

Dennis suggère de remplacer _/2+$$ÐḟparIċ¥Ðf2 ; J'avais complètement oublié la possibilité d'un filtre dyadique. En tant que tel, cet algorithme est désormais lié à celui que la réponse de Dennis a utilisé.

Explication

’ÆRṡ2Iċ¥Ðf2FİS
’                  Decrement.
 ÆR                Primes from 2 to the argument inclusive
                   (i.e. 2 to the original input exclusive).
   ṡ2              Take overlapping slices of size 2.
        Ðf         Keep only elements where the following is true:
       ¥           {the second parse of, which parses like this}
     Iċ   2          the differences (I) contain (ċ) 2
           F       Flatten.
            İ      Take 1/x {for every list element}.
             S     Sum.

Brachylog , 17 octets

{>I-₂:I{ṗ/₁}ᵐ}ᶠc+

Essayez-le en ligne!

Ceci est la toute nouvelle version de Brachylog, avec une page de code brillante!

Explication

{            }ᶠ        Find all valid outputs of the predicate in brackets
               c+      Output is the sum of that list after flattening it

 >I                    Input > I
   -₂:I                The list [I-2, I]
       {   }ᵐ          Map:
        ṗ/₁              Must be prime and the output is its inverse

MATL , 16 octets

liqZqtd2=)t2+h/s

Essayez-le en ligne!

Considérez la saisie 13comme exemple.

l     % Push 1
      %   STACK: 1
i     % Input N
      %   STACK: 1, 13
q     % Subtract 1
      %   STACK: 1, 12
Zq    % Primes up to that
      %   STACK: 1, [2 3 5 7 11]
t     % Duplicate
      %   STACK: 1, [2 3 5 7 11], [2 3 5 7 11]
d     % Consecutive differences
      %   STACK: 1, [2 3 5 7 11], [1 2 2 4]
2=    % Compare with 2, element-wise
      %   STACK: 1, [2 3 5 7 11], [0 1 1 0]
)     % Use as logical index to select elements from array
      %   STACK: 1, [3 5]
t     % Duplicate
      %   STACK: 1, [3 5], [3 5]
2+    % Add 2, element-wise
      %   STACK: 1, [3 5], [5 7]
h     % Concatenate horizontally
      %   STACK: 1, [3 5 5 7]
/     % Divide, element-wise
      %   STACK: [0.3333 0.2 0.2 0.1429]
s     % Sum of array. Implicitly display
      %   STACK: 0.8762

Mathematica, 48 47 octets

Merci à JungHwan Min pour avoir économisé 1 octet!

If[PrimeQ/@(i&&(g=i-2)),1/i+1/g,0]~Sum~{i,#-1}&

Fonction sans nom prenant un entier positif en entrée et retournant une fraction exacte; par exemple, If[PrimeQ/@(i&&(g=i-2)),1/i+1/g,0]~Sum~{i,#-1}&[10]renvoie 92/105.

If[PrimeQ/@(i&&(g=i-2)),1/i+1/g,0]teste si les deux iet i-2sont premiers, renvoyant la somme de leurs inverses si oui et 0si non. ~Sum~{i,#-1}&renvoie ensuite la somme de ces contributions pour toutes les valeurs dei inférieures à l'entrée.

Soumission précédente:

If[And@@PrimeQ@{i,g=i-2},1/i+1/g,0]~Sum~{i,#-1}&

Octave, 45 octets

@(n)sum(all(isprime(m=[h=3:n-1;h-2]))*m'.^-1)

Explication:

m=[h=3:n-1;h-2]             generate an concatenate two ranges 3:n-1 and 1:n-3
rec=m'.^-1                  transpose and reciprocal
idx=all(isprime(m))         create a logical [0 1 ..] array  if both ranges are prime set 1 else set 0
sum1 = idx * rec            matrix multiplication(extrat elements with logical index and sum along the first dimension)
sum(sum1)                   sum along the second dimension  

Essayez-le en ligne!

JavaScript (ES6), 67 66 octets

1 octet enregistré grâce à @Arnauld

f=n=>--n>1&&((p=x=>n%--x?p(x):x==1)(n)&&p(n-=2)&&1/n+++1/++n)+f(n)

Sorties falsepour le cas de test 2, ce qui est autorisé par défaut .

Extrait de test

f=n=>--n>1&&((p=x=>n%--x?p(x):x==1)(n)&&p(n-=2)&&1/n+++1/++n)+f(n)

g=n=>console.log("Input:",n,"Output:",f(n))

g(2)
g(6)
g(10)
g(13)
g(100)
g(620)

05AB1E , 19 14 octets (-5 @Emigna)

<LDpÏÍDpÏDÌ«zO

Essayez-le en ligne!

Gelée , 19 octets

’ÆRḊµ_Æp=2Tịµ_2;µİS

Essayez-le en ligne!

J'ai le sentiment que cela peut être amélioré, mais je ne vois pas immédiatement comment.

Explication

’ÆRḊµ_Æp=2Tịµ_2;µİS
 ÆR                  Generate all primes from 2 to n inclusive
’                    Subtract 1
   Ḋ                 Remove first element
’ÆRḊ                 Generate all primes from 3 to n-1 exclusive

     _Æp             Subtract the previous prime (i.e. calculate the prime gap)
        =2           Compare to 2
          Tị         Take elements of the input where the comparison is true
     _Æp=2Tị         Filter a list of primes to the latter halves of prime pairs

             _2      Subtract 2
               ;     Append
             _2;     Append the list to the list with 2 subtracted from it
                 İ   Take reciprocals
                  S  Sum
                 İS  Take the sum of the reciprocals

Les µrelient toutes ces portions ensemble de style de conduite, chaque prise de la sortie de la précédente en tant qu'entrée.

Pyth - 22 21 17 octets

Je pense que le refactoring va aider.

scL1sf.APM_MTm,tt

Suite de tests .

Perl 6 , 59 51 octets

{sum 1 «/»grep((*-(2&0)).is-prime,^$_).flatmap:{$_-2,$_}}

{sum 1 «/»grep(*.all.is-prime,(-2..*Z ^$_)).flat}

-2..* Z ^$_zippe la liste infinie -2, -1, 0, 1, ...avec la liste 0, 1, ... $_-1( $_étant l'argument de la fonction), produisant la liste (-2, 0), (-1, 1), (0, 2), ..., ($_-3, $_-1). (Évidemment, aucun de ces nombres inférieurs à 3 ne peut être dans une paire principale, mais 3..* Z 5..^$_est de quelques octets de plus, et aucun des nombres supplémentaires n'est premier.)

Le grepsélectionne uniquement les paires où tous les nombres (c'est-à-dire les deux) sont premiers, et les flataplatit en une simple liste de nombres.

«/»est l'hyperopératrice de division; avec la liste à droite et1 à gauche, il transforme la liste des paires principales en leurs inverses, qui est ensuite additionnée par sum.

Clojure, 147 octets

(fn[n](let[p #(if(> % 2)(<(.indexOf(for[a(range 2 %)](mod % a))0)0))](reduce +(for[a(range 2 n)](if(and(p a)(p(- a 2)))(+(/ 1 a)(/ 1(- a 2)))0)))))

Et Clojure vient en dernier, comme d'habitude.

Non golfé:

; Returns the primality of a number.
(defn prime? [n]
  (if (> n 2)
    (< (.indexOf (for [a (range 2 n)] (mod n a)) 0) 0)))

; Calculates the actual Brun's Constant. ' (Stupid highlighter)
(defn brunsconst [n]
  ; Adds all of the entries together
  (reduce
    +
    ; For a in range(2, n):
    (for [a (range 2 n)]
      (let [b (- a 2)]
        ; If both a and a-2 are prime:
        (if (and (prime? a) (prime? b))
          ; Place (1/a + 1/a-2) on the array, else 0
          (+ (/ 1 a) (/ 1 b)) 0)))))

Julia 0,4 , 48 46 octets

!n=sum(1./[(p=n-1|>primes)∩(p-2);p∩(p+2)])

Essayez-le en ligne!

Utilitaires Bash + GNU, 86 85 octets

for((k=4;k<$1;k++,j=k-2)){ [ `factor $k $j|wc -w` = 4 ]&&x=$x+1/$k+1/$j;};bc -l<<<0$x

Essayez-le en ligne!

Construit une grande expression arithmétique puis la nourrit bc -l pour l'évaluer.

Edit: laissé par erreur dans une paire $ (...) d'une ancienne version avec substitution de commande imbriquée; changé en backticks pour enregistrer un octet.

APL NARS, 216 octets, 108 caractères

  r←z n;h;i;k;v
  i←0⋄n-←1⋄h←1+⍳n-1⋄→B
A:k←i⊃h⋄h←k∪(0≠k∣h)/h
B:→A×⍳(⍴h)≥i+←1
  r←+/÷(v-2),v←(h=1⌽h+2)/h

cela utiliserait le "Crivello di Eratostene" pour trouver la sous-liste dans 1..arg des nombres premiers de la demande. Tester:

  z¨2 6 10 13 100 620
0 0.5333333333 0.8761904762 0.8761904762 1.330990366 1.499970603 
  z 100000
1.672799585