布伦常数是其中的倒数之和的值孪生素数对（1/p与1/(p+2)其中p和p+2都是素数）收敛。大约是1.902160583104。

给定一个正整数N，通过将双素数对中的两个素数均小于的双素数对的倒数相加来近似布伦常数N，并输出近似值。

规则

• N 将是您的语言可表示范围内的正整数。
• 在您的语言的浮点实现限制内，输出必须尽可能精确到真实值，而忽略由于浮点算术错误而引起的任何潜在问题。如果您的语言能够执行任意精度算术，则它必须至少与IEEE 754双精度算术一样精确。
• 或者，可以以任何一致，明确的格式输出精确的分数。
• 如果一个主要出现在多个孪生素对（例如5，二者的一部分(3, 5)和(5, 7)），其倒数有助于总和各一次。

测试用例

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字节

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)

感谢@xnor为2 4个字节打高尔夫球，并为另外4个字节铺平了道路！

在线尝试！

背景

回想一下威尔逊定理，对于所有整数k> 1，

其中a b（mod d）表示a-b被d整除，即a和b除以d时具有相同的残基。

在关于双阶乘，超阶，子阶和超阶乘的威尔逊定理中，作者证明了双阶乘的泛化，并以此为基础建立了答案。整数k≥0的双阶乘由下式定义

前述论文的定理4陈述如下。

将全等式的两边提升到第四次方，我们推论得出

对于所有奇数素数p。从1开始!! = 1时，等价度在p = 2时也成立。

现在，对威尔逊定理做同样的发现

以来

它遵循

只要p为质数。

现在，让k为奇数，正整数。根据定义，存在整数a，b> 1，从而k = ab。

由于k是奇数，所以a和b也是如此。因此，它们都以1、3，…，k-2和

其中| 表示可分割性。

总结，对于所有奇数整数k> 1

其中P（k）的1 =如果ķ是素数，P（k）的= 0如果ķ是复合材料。

怎么运行的

当函数˚F是带一个单个参数，ķ，米，和Ĵ初始化为3，1，和0。

注意（（k-2）!!）⁴ = 1 !! ⁴ = 1 =米。实际上，等式m =（（k-2）!!）⁴始终存在。j是一个浮点数，将始终等于（（k-4）!!）⁴％（k-2）/（k-2）。

当k <n时，and将评估的正确参数。由于j =（（k-4）!!）⁴％（k-2）/（k-2），如第一段所述，如果k-2为素数且j为j，则j = 1 /（k-2）。= 0，如果不是。同样地，由于米％K =（（K - 2）！）⁴等于1，如果ķ是素数，0如果没有，-m％K = K - 1如果ķ是素数，-m％K = 0如果不是。因此，计算结果为2（k-1）/（k（k-2））=（（k-2）+ k）/（k（k-2））= 1 / k + 1 /（k-2）如果对（k-2，k）-m%k*j*2/k由双素数组成，如果不是，则为0。

经过以上计算，我们将结果添加到递归调用的返回值中f(n,k+2,m*k**4,m%k/k)。ķ被递增2，从而只需要奇数值^‡†，我们乘法中号由ķ ⁴自MK ⁴ =（（K - 2）！）⁴ ķ ⁴ =（K !!）⁴，和通过的电流值m％k / k –作为“旧” k为质数，等于1 / k，否则为0 –作为函数调用的参数j。

最后，一旦k等于或大于n，f将返回False，并且递归停止。f（n）的返回值将是所有1 / k + 1 /（k-2）的总和，因此（k-2，k）是双素数对，并且k <n（根据需要）。

^• _{“ 背景”段落的结果仅适用于奇数整数。由于即使整数也不能是双质数，所以我们可以安全地跳过它们。}

果冻，15 14字节

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

在线尝试！

怎么运行的

’Æ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字节（在@Dennis的帮助下）

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

在线尝试！

在尝试改善以前的答案时，我想出了一种完全不同的算法，而且算法略短一些。我为此使用了不同的帖子，这是使用不同技术的答案的标准。

丹尼斯建议更换 _/2+$$Ðḟ与Iċ¥Ðf2 ; 我完全忘记了二进位过滤器的可能性。因此，此算法现在与Dennis的答案所使用的算法联系在一起。

说明

’Æ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 个字节

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

在线尝试！

这是Brachylog的全新版本，带有闪亮的代码页！

说明

{            }ᶠ        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字节

liqZqtd2=)t2+h/s

在线尝试！

以输入13为例。

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字节

感谢郑焕敏节省了1个字节！

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

未命名函数，以正整数作为输入并返回精确的分数；例如，If[PrimeQ/@(i&&(g=i-2)),1/i+1/g,0]~Sum~{i,#-1}&[10]return 92/105。

If[PrimeQ/@(i&&(g=i-2)),1/i+1/g,0]测试i和两者是否i-2均为素数，如果是，则返回它们的倒数之和0。~Sum~{i,#-1}&然后返回i小于输入的所有值的那些贡献之和。

先前提交的内容：

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

八度，45字节

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

说明：

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  

在线尝试！

JavaScript（ES6），67 66字节

@Arnauld节省了1个字节

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

产出 false测试用例的，默认情况下2是允许的。

测试片段

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字节（-5 @Emigna）

<LDpÏÍDpÏDÌ«zO

在线尝试！

果冻，19字节

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

在线尝试！

我感觉这是可以改进的，但是我无法立即看到如何做。

说明

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

所述µ连接所有这些部分共同管道式，每个取一个的输出之前作为其输入。

Pyth- 22 21 17字节

我认为重构将有所帮助。

scL1sf.APM_MTm,tt

测试套件。

Perl 6的，59 51个字节的

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

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

-2..* Z ^$_-2, -1, 0, 1, ...用列表压缩无限列表0, 1, ... $_-1（$_作为函数的参数），生成list (-2, 0), (-1, 1), (0, 2), ..., ($_-3, $_-1)。（显然，小于3的这些数字中的任何一个都不可以在质数对中，但是3..* Z 5..^$_要长几个字节，并且所有多余的数字都不是质数。）

的 grep选择只有那些对所有（即两种）数字是素数，而flat变平他们到数字的普通列表。

«/»是部门超级操作员；列表的左右两边1将素数对的列表转换为它们的倒数，然后由求和sum。

Clojure，147个字节

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

和Clojure一样，最后死了。

取消高尔夫：

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

朱0.4，48 46个字节

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

在线尝试！

Bash + GNU实用程序，86 85字节

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

在线尝试！

构造一个大的算术表达式，然后将其馈送以bc -l对其求值。

编辑：错误地从带有嵌套命令替换的旧版本中的$（...）对中离开；改为反引号以保存一个字节。

APL NARS，216字节，108个字符

  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

这将使用“ Crivello di Eratostene”在请求素数1..arg中找到子列表。测试：

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