La costante di Brun è il valore a cui converge la somma dei reciproci delle coppie gemelle prime ( 1/pe 1/(p+2)dove pe p+2sono entrambe prime). È circa 1.902160583104.

Dato un numero intero positivo N, approssimare la costante di Brun sommando i reciproci delle coppie gemelle di primi in cui entrambi i numeri primi nella coppia sono inferiori di Ne generano l'approssimazione.

Regole

• N sarà un numero intero positivo all'interno dell'intervallo rappresentabile per la tua lingua.
• L'output deve essere il più accurato possibile rispetto al valore reale, entro i limiti dell'implementazione in virgola mobile della lingua, ignorando eventuali problemi dovuti a inesattezze aritmetiche in virgola mobile. Se la tua lingua è in grado di eseguire l'aritmetica a precisione arbitraria, deve essere precisa almeno quanto l'aritmetica a doppia precisione IEEE 754.
• In alternativa, una frazione esatta può essere prodotta in qualsiasi formato coerente e non ambiguo.
• Se un numero primo appare in più coppie gemelle prime (ad esempio 5, parte di entrambi (3, 5)e (5, 7)), il suo reciproco contribuisce ogni volta alla somma.

Casi 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 byte

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)

Grazie a @xnor per il golf off 2 4 byte e spianando la strada per altri 4!

Provalo online!

sfondo

Ricordiamo che il teorema di Wilson afferma che per tutti gli interi k> 1 ,

dove a ≡ b (mod d) significa che a - b è uniformemente divisibile per d , ovvero a e b hanno lo stesso residuo se diviso per d .

Nei teoremi di Wilson per doppio, iper-, sotto- e super fattoriale , gli autori dimostrano generalizzazioni per doppi fattoriali, su cui si basa questa risposta. Il doppio fattoriale di un intero k ≥ 0 è definito da

Il teorema 4 del suddetto articolo afferma quanto segue.

Elevando entrambi i lati delle congruenze al quarto potere, lo deduciamo

per tutti i numeri primi dispari p . Dal 1 !! = 1 , l'equivalenza vale anche per p = 2 .

Ora, fare lo stesso con il teorema di Wilson lo rivela

Da

ne consegue che

ogni volta che p è primo.

Ora, lascia che k sia un numero intero dispari, positivo e composito. Per definizione, esistono numeri interi a, b> 1 tali che k = ab .

Poiché k è dispari, quindi sono un e b . Pertanto, entrambi si verificano nella sequenza 1, 3, ..., k - 2 e

dove | indica divisibilità.

Riassumendo, per tutti gli interi dispari k> 1

dove p (k) = 1 se k è primo e p (k) = 0 se k è composto.

Come funziona

Quando la funzione f viene chiamata con un singolo argomento, k , m e j vengono inizializzati come 3 , 1 e 0 .

Nota che ((k - 2) !!) ⁴ = 1 !! ⁴ = 1 = m . In effetti, l'uguaglianza m = ((k - 2) !!) ⁴ manterrà sempre. j è un float e sarà sempre uguale a ((k - 4) !!) ⁴ % (k - 2) / (k - 2) .

Mentre k <n , andverrà valutato l'argomento giusto di . Poiché j = ((k - 4) !!) ⁴ % (k - 2) / (k - 2) , come dimostrato nel primo paragrafo, j = 1 / (k - 2) se k - 2 è primo e j = 0 in caso contrario. Allo stesso modo, poiché m% k = (((k - 2) !!) ^{4 è} uguale a 1 se k è primo e 0 in caso contrario, -m% k = k - 1 se k è primo e -m% k = 0 in caso contrario. Pertanto, -m%k*j*2/kvaluta 2 (k - 1) / (k (k - 2)) = ((k - 2) + k) / (k (k - 2)) = 1 / k + 1 / (k - 2) se la coppia (k - 2, k)è composto da numeri primi gemelli e da 0 in caso contrario.

Dopo aver calcolato quanto sopra, aggiungiamo il risultato al valore restituito della chiamata ricorsiva f(n,k+2,m*k**4,m%k/k). k viene incrementato di 2, quindi richiede solo valori dispari ^{‡ †} , moltiplichiamo m per k ⁴ poiché mk ⁴ = ((k - 2) !!) ⁴ k ⁴ = (k !!) ⁴ e passiamo il valore corrente di m% k / k - che equivale a 1 / k se il "vecchio" k è un numero primo e 0 in caso contrario - come parametro j alla chiamata della funzione.

Alla fine, una volta che k è uguale o maggiore di n , f restituirà False e la ricorsione si interrompe. Il valore di ritorno di f (n) sarà la somma di tutti 1 / k + 1 / (k - 2) tale (k - 2, k) è una prima coppia gemella e k <n , come desiderato.

^‡ _{I risultati del paragrafo Sfondo valgono solo per numeri dispari. Poiché anche i numeri interi non possono essere numeri primi gemelli, possiamo saltarli in modo sicuro.}

Gelatina , 15 14 byte

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

Provalo online!

Come funziona

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

Jelly , 16 14 byte (con un piccolo aiuto di @Dennis)

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

Provalo online!

Mentre cercavo di migliorare la mia risposta precedente, ho escogitato un algoritmo completamente diverso, che viene in qualche modo più breve. Sto usando un post diverso per questo, come lo standard qui per una risposta che utilizza una tecnica diversa.

Dennis suggerisce di sostituire _/2+$$Ðḟcon Iċ¥Ðf2; Mi ero completamente dimenticato della possibilità di un filtro diadico. Pertanto, questo algoritmo ora si lega a quello utilizzato dalla risposta di Dennis.

Spiegazione

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

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

Provalo online!

Questa è la nuovissima versione di Brachylog, con una brillante tabella codici!

Spiegazione

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

liqZqtd2=)t2+h/s

Provalo online!

Considera l'input 13come esempio.

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 byte

Grazie a JungHwan Min per aver salvato 1 byte!

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

Funzione senza nome che accetta un numero intero positivo come input e restituisce una frazione esatta; ad esempio, If[PrimeQ/@(i&&(g=i-2)),1/i+1/g,0]~Sum~{i,#-1}&[10]restituisce 92/105.

If[PrimeQ/@(i&&(g=i-2)),1/i+1/g,0]verifica se entrambi ie i-2sono primi, restituendo la somma dei reciproci in tal 0caso e in caso contrario. ~Sum~{i,#-1}&quindi restituisce la somma di tali contributi per tutti i valori iinferiori all'input.

Presentazione precedente:

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

Ottava, 45 byte

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

Spiegazione:

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  

Provalo online!

JavaScript (ES6), 67 66 byte

Salvato 1 byte grazie a @Arnauld

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

Output falseper test case 2, consentito per impostazione predefinita .

Snippet di prova

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

<LDpÏÍDpÏDÌ«zO

Provalo online!

Gelatina , 19 byte

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

Provalo online!

Ho la sensazione che questo sia migliorabile, ma non riesco immediatamente a vedere come.

Spiegazione

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

I µconnect tutte queste porzioni insieme conduttura stile, con ciascuna prendendo l'uscita di quello precedente come input.

Pyth - 22 21 17 byte

Penso che il refactoring aiuterà.

scL1sf.APM_MTm,tt

Test Suite .

Perl 6 , 59 51 byte

{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( $_essendo l'argomento della funzione), producendo la lista(-2, 0), (-1, 1), (0, 2), ..., ($_-3, $_-1) . (Ovviamente nessuno di questi numeri inferiori a 3 può essere in una coppia primo, ma 3..* Z 5..^$_è più lungo di pochi byte e nessuno dei numeri extra è primo.)

Gli grepseleziona solo quelle coppie dove tutto (cioè, entrambe) numeri sono primi ei flatli appiattisce in un semplice elenco di numeri.

«/»è l'iperoperatore di divisione; con l'elenco a destra e 1a sinistra, trasforma l'elenco delle coppie primi nei loro reciproci, che viene quindi sommato da sum.

Clojure, 147 byte

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

E Clojure è morto per ultimo, come al solito.

Ungolfed:

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

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

Provalo online!

Utilità Bash + GNU, 86 85 byte

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

Provalo online!

Costruisce una grande espressione aritmetica e quindi la nutre bc -l per valutarla.

Modifica: lasciato erroneamente in una coppia $ (...) da una vecchia versione con sostituzione di comando nidificata; modificato in backtick per salvare un byte.

APL NARS, 216 byte, 108 caratteri

  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

questo userebbe il "Crivello di Eratostene" per trovare la sotto-lista in 1..arg di numeri primi di richiesta. Test:

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