La constante de Brun es el valor al que converge la suma de los recíprocos de los pares primos gemelos ( 1/py 1/(p+2)dónde py p+2ambos son primos). Es aproximadamente 1.902160583104.

Dado un entero positivo N, aproxima la constante de Brun sumando los recíprocos de los pares primos gemelos donde ambos primos en el par son menores que N, y genera la aproximación.

Reglas

• N será un número entero positivo dentro del rango representable para su idioma.
• La salida debe ser lo más precisa posible al valor verdadero, dentro de los límites de la implementación de punto flotante de su idioma, ignorando cualquier problema potencial debido a imprecisiones aritméticas de punto flotante. Si su lenguaje es capaz de aritmética de precisión arbitraria, debe ser al menos tan precisa como la aritmética de precisión doble IEEE 754.
• Alternativamente, se puede generar una fracción exacta en cualquier formato consistente y sin ambigüedades.
• Si un primo aparece en múltiples pares primos gemelos (por ejemplo 5, parte de ambos (3, 5)y (5, 7)), su recíproco contribuye a la suma cada vez.

Casos de prueba

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 bytes

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)

¡Gracias a @xnor por jugar 2 4 bytes y allanar el camino para 4 más!

Pruébalo en línea!

Fondo

Recordemos que el teorema de Wilson establece que para todos los enteros k> 1 ,

donde a ≡ b (mod d) significa que a - b es divisible por d , es decir, a y b tienen el mismo residuo cuando se divide por d .

En Wilson Theorems for Double-, Hyper-, Sub- and Super-factorials , los autores prueban generalizaciones para factoriales dobles, sobre los que se basa esta respuesta. El factorial doble de un entero k ≥ 0 se define por

El teorema 4 del trabajo antes mencionado establece lo siguiente.

Elevando ambos lados de las congruencias al cuarto poder, deducimos que

para todos los números primos impares p . Desde 1 !! = 1 , la equivalencia se cumple también para p = 2 .

Ahora, hacer lo mismo con el teorema de Wilson revela que

Ya que

resulta que

siempre que p es primo.

Ahora, que k sea ​​un número entero extraño, positivo y compuesto. Por definición, existen enteros a, b> 1 tales que k = ab .

Como k es impar, también lo son a y b . Por lo tanto, ambos ocurren en la secuencia 1, 3, ..., k - 2 y

donde | Indica divisibilidad.

Resumiendo, para todos los enteros impares k> 1

donde p (k) = 1 si k es primo y p (k) = 0 si k es compuesto.

Cómo funciona

Cuando se llama a la función f con un único argumento, k , m y j se inicializan como 3 , 1 y 0 .

Tenga en cuenta que ((k - 2) !!) ⁴ = 1 !! ⁴ = 1 = m . De hecho, la igualdad m = ((k - 2) !!) ⁴ se mantendrá en todo momento. j es flotante y siempre será igual a ((k - 4) !!) ⁴ % (k - 2) / (k - 2) .

Mientras k <n , andse evaluará el argumento correcto de . Como j = ((k - 4) !!) ⁴ % (k - 2) / (k - 2) , como se demuestra en el primer párrafo, j = 1 / (k - 2) si k - 2 es primo y j = 0 si no. Del mismo modo, dado que m% k = ((k - 2) !!) ⁴ es igual a 1 si k es primo y 0 si no, -m% k = k - 1 si k es primo y -m% k = 0 si no. Por lo tanto, se -m%k*j*2/kevalúa como 2 (k - 1) / (k (k - 2)) = ((k - 2) + k) / (k (k - 2)) = 1 / k + 1 / (k - 2) si el par (k - 2, k)consiste en primos gemelos y en 0 si no.

Después de calcular lo anterior, agregamos el resultado al valor de retorno de la llamada recursiva f(n,k+2,m*k**4,m%k/k). k se incrementa en 2, por lo que solo toma valores impares ^{‡ †} , multiplicamos m por k ⁴ ya que mk ⁴ = ((k - 2) !!) ⁴ k ⁴ = (k !!) ⁴ y pasamos el valor actual de m% k / k , que es igual a 1 / k si el "viejo" k es primo y 0 si no, como parámetro j para la llamada a la función.

Finalmente, una vez que k es igual o mayor que n , f devolverá False y la recursión se detendrá. El valor de retorno de f (n) será la suma de todos 1 / k + 1 / (k - 2) tal que (k - 2, k) es un par primo gemelo yk <n , según se desee.

^‡ _{Los resultados del párrafo Fondo solo se mantienen para enteros impares. Dado que incluso los enteros no pueden ser primos gemelos, podemos omitirlos de manera segura.}

Jalea , 15 14 bytes

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

Pruébalo en línea!

Cómo funciona

’Æ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.

Gelatina , 16 14 bytes (con un poco de ayuda de @Dennis)

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

Pruébalo en línea!

Mientras intentaba mejorar mi respuesta anterior, pensé en un algoritmo totalmente diferente, y es algo más corto. Estoy usando una publicación diferente, como es el estándar aquí para una respuesta que usa una técnica diferente.

Dennis sugiriendo reemplazar _/2+$$ÐḟconIċ¥Ðf2 ; Me había olvidado por completo de la posibilidad de un filtro diádico. Como tal, este algoritmo ahora se vincula con el que utilizó la respuesta de Dennis.

Explicación

’Æ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 bytes

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

Pruébalo en línea!

¡Esta es la nueva versión de Brachylog, con una página de códigos brillante!

Explicación

{            }ᶠ        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 bytes

liqZqtd2=)t2+h/s

Pruébalo en línea!

Considere la entrada 13como un ejemplo.

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 bytes

¡Gracias a JungHwan Min por guardar 1 byte!

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

Función sin nombre que toma un entero positivo como entrada y devuelve una fracción exacta; por ejemplo, If[PrimeQ/@(i&&(g=i-2)),1/i+1/g,0]~Sum~{i,#-1}&[10]devuelve92/105 .

If[PrimeQ/@(i&&(g=i-2)),1/i+1/g,0]prueba si ambos iyi-2 son primos, devolviendo la suma de sus recíprocos si es así y 0si no. ~Sum~{i,#-1}&luego devuelve la suma de esas contribuciones para todos los valores imenores que la entrada.

Presentación previa:

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

Octava, 45 bytes

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

Explicación:

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  

¡Pruébelo en línea!

JavaScript (ES6), 67 66 bytes

Guardado 1 byte gracias a @Arnauld

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

Salidas falsepara caso de prueba 2, que está permitido por defecto .

Fragmento de prueba

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 bytes (-5 @Emigna)

<LDpÏÍDpÏDÌ«zO

Pruébalo en línea!

Jalea , 19 bytes

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

Pruébalo en línea!

Tengo la sensación de que esto es mejorable, pero no puedo ver de inmediato cómo.

Explicación

’Æ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

Los µConnect todas estas porciones junto tubería de estilo, con cada uno tomando la salida de la anterior como su entrada.

Pyth - 22 21 17 bytes

Creo que la refactorización ayudará.

scL1sf.APM_MTm,tt

Test Suite .

Perl 6 , 59 51 bytes

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

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

-2..* Z ^$_comprime la lista infinita -2, -1, 0, 1, ...con la lista 0, 1, ... $_-1( $_siendo el argumento de la función), produciendo la lista (-2, 0), (-1, 1), (0, 2), ..., ($_-3, $_-1). (Obviamente, ninguno de estos números menores que 3 puede estar en un par primo, pero 3..* Z 5..^$_es unos pocos bytes más largo y ninguno de los números adicionales es primo).

Los grepselecciona sólo aquellas parejas donde todos (es decir, ambos números) son primos, y los flatellos se aplana en una lista simple de números.

«/»es el hiperoperador de división; con la lista a la derecha y 1a la izquierda, convierte la lista de pares primos en sus recíprocos, que luego se suma por sum.

Clojure, 147 bytes

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

Y Clojure viene último, como siempre.

Sin 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 bytes

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

Pruébalo en línea!

Bash + utilidades GNU, 86 85 bytes

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

Pruébalo en línea!

Construye una gran expresión aritmética y luego la alimenta bc -lpara evaluarla.

Editar: se dejó por error en un par $ (...) de una versión anterior con sustitución de comando anidada; cambiado a backticks para guardar un byte.

NARS APL, 216 bytes, 108 caracteres

  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

esto usaría el "Crivello di Eratostene" para encontrar la sublista en 1..arg de primos de solicitud. Prueba:

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