fundo

Considere a seguinte sequência ( A051935 no OEIS):

• Comece com o termo .$2$
• Encontre o número inteiro mais baixo maior que modo que seja primo.2 2 + $n$$2$$2+n$
• Encontre o número inteiro mais baixo maior que modo que seja primo etc. n 2 + n + n $n'$$n$$2 + n + n'$

Uma definição mais formal:

Os primeiros termos da sequência são (consulte estes como casos de teste):

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

Tarefa

Sua tarefa é gerar essa sequência de qualquer uma das seguintes maneiras:

• Produza seus termos indefinidamente.
• Dado $n$ , $a_{n}$ ( $n^{\text{th}}$ termo, $0$ ou $1$ indexado).
• Dado $n$ , saída $\{a_1, a_2, \dots, a_n\}$ (primeiros $n$ termos).

Você pode competir em qualquer linguagem de programação e pode receber e fornecer saída por qualquer método padrão , observando que essas brechas são proibidas por padrão. Isso é código-golfe , então a submissão mais curta (em bytes) para todos os idiomas vence.

Braquilog , 13 bytes

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

Experimente online!

Saída é a lista dos primeiros n termos da sequência.

?~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 bytes

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

Experimente online!

Geléia , 11 9 bytes

0Ḥ_ÆnɗСI

Este é um programa completo que aceita n como argumento e imprime os primeiros n termos da sequência.

Experimente online!

Como funciona

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 bytes

2λλOD₁+ÅNα

Experimente online!

Isso funciona apenas na versão não herdada, reescrita pelo Elixir. Produz um fluxo infinito de números inteiros. Existem alguns bugs no teste principal que foram corrigidos nas confirmações mais recentes, mas ainda não estão ativos no TIO. Mas funciona localmente. Aqui está um GIF de sua execução na minha máquina, modificado para gerar os primeiros termos em vez de todo o fluxo.

Como funciona

2λ

Define uma sequência infinita recursiva com o caso base . A estrutura está entre os novos recursos muito interessantes do 05AB1E. Resumidamente, assume uma função , configurando para o argumento inteiro dado, neste caso .a ( n ) a ( 0 ) $2$λ$a(n)$$a(0)$$2$

λO

Nesta parte do código, λa função de é diferente. Já estando dentro de um ambiente recursivo, ele gera , a lista de todos os resultados anteriores. Então, resume-os.$[a(0),a(1),\dots,a(n-1)]$O

D₁+

Duplique a soma para uso posterior e adicione à segunda cópia.$a(n-1)$

ÅN

Gera o menor primo estritamente maior que a soma acima.

α

Por fim, recupere a diferença absoluta entre o prime calculado acima e a primeira cópia da soma calculada anteriormente (a soma de todas as iterações anteriores).

O fluxo é impresso implicitamente para STDOUT indefinidamente.

Perl 6 , 45 bytes

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

Experimente online!

Retorna uma lista lenta que gera a sequência sem fim.

Explicação:

Isso usa o operador Sequence, ...que define a sequência como:

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

Ruby -rprime , 34 bytes

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

Experimente online!

Saídas indefinidamente.

JavaScript (ES6), 63 bytes

Retorna o termo , indexado em 1.$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++))()

Experimente online!

Pyth ,12 11 bytes

.f&P-;Z=-;Z

Experimente online!

Guardado 1 byte graças a isaacg.

Gera os primeiros nnúmeros desse tipo, usando um índice baseado em 1.

.flocaliza os primeiros knúmeros inteiros que atendem a um critério específico, começando do zero. Aqui, o critério é que o primo anterior que calculamos ;, mais o número atual Z, seja primo ( P). Se for, também atualizamos o último primo calculado usando o comportamento em curto-circuito da lógica e da função ( &). Infelizmente .f, a variável padrão é Zque custa um byte na atualização.

O truque que isaacg descobriu foi armazenar a negação do último primo e testar esse valor menos o valor atual. Isso é mais curto em Pyth, pois a verificação de primalidade está sobrecarregada: em números positivos encontra a fatoração primária, enquanto em números negativos determina se o valor positivo do número é primo.

Isso se traduz mais ou menos em:

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 bytes

O2hGq:"t0)yd0)+_Yqh]d

Experimente online!

Saída são os primeiros n termos da sequência.

Explicação:

Constrói uma lista de números primos (com um 0 inicial) e, no final, encontra os retornos das diferenças entre números primos sucessivos na lista.

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

(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

Experimente online!

(1#1)2 2é uma função que não recebe entrada e gera uma lista infinita.

resposta antiga:

Haskell , 88 83 78 76 bytes

O teste de primalidade é desta resposta e aprimorado por Christian Sievers (-2 bytes).

-5 bytes graças a 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

Experimente online!

05AB1E (herdado) , 12 bytes

0U[XN+DpiN,U

Experimente online!

Explicação

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

Existem algumas soluções diferentes de 12 bytes possíveis.
Esse em particular poderia ter 10 bytes se tivéssemos uma variável utilizável inicializada como 0 (em vez de 1 e 2).

Python 2 , 119 bytes

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

Experimente online!

Próxima função Prime (f) tirada desta resposta .

A função g () pega um número inteiro não negativo ie retorna uma lista de todos os itens na sequência até esse índice.

Python 2 , 99 98 bytes

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

Experimente online!

1 byte thx para o Sr. Xcoder .

Haskell , 101 99 97 bytes

A função lnão aceita argumentos e retorna uma lista infinita. Não é tão curto quanto a abordagem mais direta dos @ovs (e eu obviamente roubei algumas partes da resposta), mas talvez ainda seja um jogo de golfe?

Obrigado @ H.PWiz por -2 bytes!

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]

Experimente online!

Python 2 , 82 80 bytes

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

Experimente online!

Isso gera o enésimo número da sequência (com base em 0). Ao mover o printloop, isso pode ser modificado para gerar os primeiros nitens no mesmo número de conta: Experimente online!

C (gcc) , 100 99 bytes

• Guardou um byte graças ao ceilingcat .

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

Experimente online!

Japonês, 17 bytes

Emite o nth th termo, indexado em 0.

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

Tente