Фон

Рассмотрим следующую последовательность ( A051935 в OEIS):

• Начните с термина .$2$
• Найдите младшее целое число большее 2, такое, что 2 + n простое.$n$$2$$2+n$
• Найдите наименьшее целое число больше n, такое, что 2 + n + n ' простое и т. Д.$n'$$n$$2 + n + n'$

Более формальное определение:

Первые несколько терминов последовательности (пожалуйста, обозначьте их как контрольные примеры):

2, 3, 6, 8, 10, 12, 18, 20, 22, 26, 30, 34, 36, 42, 44, 46, 50, 52, 60, 66, 72, 74, ...

задача

Ваша задача - сгенерировать эту последовательность любым из следующих способов:

• Выводим его условия на неопределенный срок.
• Для данного выведите a n ( n- й член, 0 или 1 проиндексированный).$n$$a_{n}$$n^{\text{th}}$$0$$1$
• Для заданного выведите { a 1 , a 2 , … , a n } (первые n членов).$n$$\{a_1, a_2, \dots, a_n\}$$n$

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

Брахилог , 13 байт

~l.<₁a₀ᵇ+ᵐṗᵐ∧

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

Выходом является список первых n членов последовательности.

?~l.<₁a₀ᵇ+ᵐṗᵐ∧    Full code (? at beginning is implicit)

?~l.              Output is a list whose length is the input
    <₁            Output is an increasing list
      a₀ᵇ+ᵐ       And the cumulative sum of the output
           ṗᵐ     Consists only of prime numbers
             ∧    No further constraints on output

Explanation for a₀ᵇ+ᵐ:
a₀ᵇ               Get the list of all prefixes of the list
                  Is returned in increasing order of length
                  For eg. [2, 3, 6, 8] -> [[2], [2, 3], [2, 3, 6], [2, 3, 6, 8]]
   +ᵐ             Sum each inner list  -> [2, 5, 11, 19]

Python 2 , 63 62 байта

n=f=a=b=1
while 1:
 f*=n;n+=1;a+=1
 if~f%n<a-b:print a;b=a;a=0

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

Желе , 11 9 байт

0Ḥ_ÆnɗСI

Это полная программа, которая принимает n в качестве аргумента и печатает первые n членов последовательности.

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

Как это устроено

0Ḥ_ÆnɗСI  Main link. Argument: n

0          Set the return value to 0.
      С   Accumulating iterate. When acting on a dyadic link d and called with
           arguments x and y, the resulting quicklink executes
           "x, y = d(x, y), x" n times, returning all intermediate values of x.
           Initially, x = 0 and  y = n.
     ɗ       Drei; combine the three links to the left into a dyadic chain.
 Ḥ             Unhalve; double the left argument.
  _            Subtract the right argument.
   Æn          Compute the next prime.
           This computes the partial sums of the sequence a, starting with 0.
        I  Increments; compute the forward differences.

05AB1E v2 , 10 байтов

2λλOD₁+ÅNα

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

Это работает только в устаревшей версии, переписать Elixir. Выводит бесконечный поток целых чисел. В основном тесте есть некоторые ошибки, которые были исправлены в последних коммитах, но еще не запущены на TIO. Это работает локально, хотя. Вот GIF его выполнения на моей машине, модифицированный для вывода первых нескольких терминов, а не всего потока.

Как это устроено

2λ

$2$λ$a(n)$$a(0)$$2$

λO

λ$[a(0),a(1),\dots,a(n-1)]$O

D₁+

$a(n-1)$

ÅN

Генерирует самое низкое простое число, которое больше, чем указанная выше сумма.

α

Наконец, извлеките абсолютную разницу между простым числом, вычисленным выше, и первой копией суммы, вычисленной ранее (сумма всех предыдущих итераций).

Затем поток неявно печатается в STDOUT на неопределенный срок.

Perl 6 , 45 байт

2,{first (*+@_.sum).is-prime,@_[*-1]^..*}...*

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

Возвращает ленивый список, который генерирует последовательность без конца.

Объяснение:

При этом используется оператор Sequence, ...который определяет последовательность как:

2,  # The first element is 2
  {  # The next element is:
    first  # The first value that:
          (*+@_.sum).is-prime,  # When added to the sum is a prime
          @_[*-1]^..*  # And is larger than the previous element
  }
...*  # And continue the sequence indefinitely

Рубин -rprime , 34 байта

2.step{|i|$.+=p(i)if($.+i).prime?}

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

Выходы на неопределенный срок.

JavaScript (ES6), 63 байта

$n^{th}$

n=>(k=0,s=1,g=d=>s%d?g(d-1):d<2?--n?g(s-=k-(k=s)):s-k:g(s++))()

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

Пиф ,12 11 байт

.f&P-;Z=-;Z

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

Сохранено 1 байт благодаря isaacg.

Создает первые nтакие числа, используя индекс на основе 1.

.fнаходит первые kцелые числа, которые удовлетворяют определенному критерию, начиная с нуля. Здесь критерий состоит в том, что предыдущее простое число, которое мы вычислили ;, плюс текущее число Z, является простым ( P). Если это так, мы также обновляем последнее вычисленное простое число, используя короткое замыкание логики и функции ( &). К сожалению .f, переменная по умолчанию - Zэто байт в обновлении.

Хитрость, которую выяснил isaacg, состояла в том, чтобы сохранить отрицание последнего простого числа и проверить его на минус текущее значение. В Pyth это короче, так как проверка первичности перегружена: для положительных чисел он находит простую факторизацию, а для отрицательных чисел он определяет, является ли положительное значение числа простым.

Это более или менее означает:

to_find = input()
last_prime = 0
current = 0
results = []
while to_find > 0:
    if is_prime( current + last_prime ):
        results.append( current )
        to_find -= 1
        last_prime += current
    current += 1
print results

MATL , 21 байт

O2hGq:"t0)yd0)+_Yqh]d

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

Выходными данными являются первые n членов последовательности.

Объяснение:

Создает список простых чисел (с начальным 0) и в конце находит возвраты различий между последовательными простыми числами в списке.

              % Implicit input, say n
O2h           % Push P = [0, 2] on the stack 
Gq:"          % for loop: 1 to n-1
  t0)           % Take the last element of P
                %  Stack: [[0, 2], [2]] (in first iteration)
  yd0)          % Take the difference between the last
                %   two elements of P
                %  Stack: [[0, 2], [2], [2]]
  +             % Add those up
                %  Stack: [[0, 2], [4]]
  _Yq           % Get the next prime higher than that sum
                %  Stack: [[0, 2], [5]]
  h             % Concatenate that to the list P
                %  Stack: [[0, 2, 5]]
]             % End for loop
d             % Get the differences between successive elements of
              %   the final list P

Haskell , 67 байт

(1#1)2 2
(p#n)s k|p`mod`n>0,n-s>k=k:(p#n)n(n-s)|w<-p*n=(w#(n+1))s k

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

(1#1)2 2это функция, которая не требует ввода и выводит бесконечный список

старый ответ:

Haskell , 88 83 78 76 байтов

Тест на простоту взят из этого ответа и улучшен Кристианом Сиверсом (-2 байта).

-5 байт благодаря WW .

2#2
(p#s)n|n<1=p|w<-until(\m->mod(product[1..m-1])m>0)(+1)$s+p+1=(w-s)#w$n-1

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

05AB1E (наследие) , 12 байтов

0U[XN+DpiN,U

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

объяснение

0U              # initialize X as 0
  [             # start an infinite loop
   XN+          # add X to N (the current iteration number)
      Dpi       # if the sum is prime:
         N,     #   print N
           U    #   and store the sum in X

Возможно несколько различных 12-байтовых решений.
Этот конкретный мог бы быть 10 байтов, если бы мы имели пригодную для использования переменную, инициализированную как 0 (вместо 1 и 2).

Python 2 , 119 байт

f=lambda n,k=1,m=1:m%k*k>n or-~f(n,k+1,m*k*k)
def g(i):
 r=[2]
 for j in range(i):r+=[f(sum(r)+r[-1])-sum(r)]
 return r

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

Следующая простая функция f () взята из этого ответа .

Функция g () принимает неотрицательное целое число i и возвращает список всех элементов в последовательности до этого индекса.

Python 2 , 99 98 байт

def f(n,s=2,v=2):
 k=s-~v
 while any(k%i<1for i in range(2,k)):k+=1
 return n and f(n-1,k,k-s)or v

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

1 байт спасибо мистеру Xcoder .

Haskell , 101 99 97 байт

Функция не lпринимает аргументов и возвращает бесконечный список. Не такой короткий, как более прямой подход @ovs (и я, очевидно, украл некоторые части из их ответа), но, возможно, все еще пригоден для игры в гольф?

Спасибо @ H.PWiz за -2 байта!

import Data.List
p m=mod(product[1..m-1])m>0
l=2:[until(p.(+sum a))(+1)$last a+1|a<-tail$inits l]

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

Python 2 , 82 80 байт

s=p=2
i=input()
P=n=1
while i:
 P*=n;n+=1
 if P%n>0<n-s-p:p=n-s;s=n;i-=1
print p

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

Это выводит n-й номер последовательности (на основе 0). Перемещая printв цикле, это можно изменить, чтобы выводить первые nэлементы с той же учетной записью: попробуйте онлайн!

C (gcc) , 100 99 байт

• Сохраненный байт благодаря потолку .

p(r,i,m,a,l){for(l=m=a=0;a-r;)m+=i=p(a++);while(r*!l)for(++i,l=a=2;a-m-i;)l=(m+i)%a++?l:0;r=r?i:2;}

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

Japt, 17 байт

Выводит n0-й член, 0-индексированный.

@_+T j}aXÄT±X}g2ì

Попытайся