Константа Бруна - это значение, к которому сходится сумма обратных величин двойных простых пар ( 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 .

В теоремах Вильсона для двойных, гипер-, суб- и супер-факториалов авторы доказывают обобщения для двойных факториалов, на которых основывается этот ответ. Двойной факториал целого числа к ^ 0 определяется

Теорема 4 вышеупомянутой статьи утверждает следующее.

Повышая обе стороны сравнений до четвертой степени, мы выводим, что

для всех нечетных простых чисел р . С 1 года !! = 1 , эквивалентность верна и для p = 2 .

Теперь, делая то же самое с теоремой Уилсона,

поскольку

следует, что

всякий раз, когда р простое.

Теперь пусть k будет нечетным, положительным, составным целым числом. По определению существуют целые числа a, b> 1, такие что k = ab .

Так как k нечетно, то и a и b . Таким образом, оба встречаются в последовательности 1, 3,…, k - 2 и

где | указывает на делимость.

Суммируя, для всех нечетных целых чисел k> 1

где p (k) = 1, если k простое, и p (k) = 0, если k составное.

Как это работает

Когда функция f вызывается с одним аргументом, k , m и j инициализируются как 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) , как доказано в первом абзаце, j = 1 / (k - 2), если k - 2 простое и j = 0, если нет. Аналогично, поскольку m% k = ((k - 2) !!) ⁴ равно 1, если k простое, и 0, если нет, -m% k = k - 1, если простое k, и -m% k = 0, если нет. Следовательно, -m%k*j*2/kоценивается как 2 (k - 1) / (k (k - 2)) = ((k - 2) + k) / (k (k - 2)) = 1 / k + 1 / (k - 2) если пара (k - 2, k)состоит из двух простых чисел и 0, если нет.

Вычислив вышеизложенное, мы добавляем результат к возвращаемому значению рекурсивного вызова f(n,k+2,m*k**4,m%k/k). k увеличивается на 2, поэтому он принимает только нечетные значения ^{‡ †} , мы умножаем m на k ^4, поскольку mk ⁴ = ((k - 2) !!) ⁴ k ⁴ = (k !!) ⁴ , и передаем текущее значение m% k / k - что равно 1 / k, если «старое» k - простое число, и 0, если нет - как параметр j для вызова функции.

Наконец, когда k равно или больше n , f возвращает False, и рекурсия прекращается. Возвращаемое значение f (n) будет суммой всех 1 / k + 1 / (k - 2), таких (k - 2, k) - двойная простая пара, и k <n , по желанию.

^‡ _{Результаты из абзаца Background сохраняются только для нечетных целых чисел. Поскольку даже целые числа не могут быть двойными простыми числами, мы можем их безопасно пропустить.}

Желе , 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.

Желе , 16 14 байт (с небольшой помощью @Dennis)

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

Попробуйте онлайн!

Пытаясь улучшить свой предыдущий ответ, я придумал совершенно другой алгоритм, и он несколько короче. Я использую для этого другой пост, как здесь стандарт для ответа, который использует другую технику.

Денис предлагает заменить _/2+$$ÐḟнаIċ¥Ðf2 ; Я полностью забыл о возможности диадического фильтра. Таким образом, этот алгоритм теперь связан с тем, который использовал ответ Денниса.

объяснение

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

Брахилог , 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 байтов

Спасибо JungHwan Min за сохранение 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]возвращает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 байт

Сохранено 1 байт благодаря @Arnauld

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( $_являющимся аргументом функции), создавая список(-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 приходит мертвым последним, как обычно.

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

Юлия 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его оценки.

Редактировать: по ошибке оставили в паре $ (...) из старой версии с вложенной подстановкой команд; изменил на backticks, чтобы сохранить байт.

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