Antecedentes

Considere la siguiente secuencia ( A051935 en OEIS):

• Comience con el término .$2$
• Encuentre el número entero más bajo mayor que modo que sea ​​primo.2 2 + $n$$2$$2+n$
• Encuentre el número entero más bajo mayor que modo que sea ​​primo, etc. n 2 + n + n $n'$$n$$2 + n + n'$

Una definición más formal:

Los primeros términos de la secuencia son (refiérase a estos como casos de prueba):

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

Tarea

Su tarea es generar esta secuencia de cualquiera de las siguientes maneras:

• Produzca sus términos indefinidamente.
• Dado $n$ , salida $a_{n}$ ( $n^{\text{th}}$ término, $0$ o $1$ indexado).
• Dado $n$ , salida $\{a_1, a_2, \dots, a_n\}$ (primeros $n$ términos).

Puede competir en cualquier lenguaje de programación y puede tomar entradas y proporcionar salidas a través de cualquier método estándar , mientras toma nota de que estas lagunas están prohibidas por defecto. Este es el código de golf , por lo que gana el envío más corto (en bytes) para cada idioma .

Brachylog , 13 bytes

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

Pruébalo en línea!

La salida es la lista de los primeros n términos de la secuencia.

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

Pruébalo en línea!

Jalea , 11 9 bytes

0Ḥ_ÆnɗСI

Este es un programa completo que toma n como argumento e imprime los primeros n términos de la secuencia.

Pruébalo en línea!

Cómo 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α

Pruébalo en línea!

Esto solo funciona en la versión no heredada, la reescritura de Elixir. Emite una secuencia infinita de enteros. Hay algunos errores con la prueba principal que se han corregido en las últimas confirmaciones, pero que aún no están en vivo en TIO. Sin embargo, funciona localmente. Aquí hay un GIF de su ejecución en mi máquina, modificado para generar los primeros términos en lugar de la secuencia completa.

Cómo funciona

2λ

Define una secuencia infinita recursiva con el caso base . La estructura se encuentra entre las nuevas características muy interesantes de 05AB1E. En pocas palabras, toma una función , estableciendo al argumento entero dado, en este caso .a ( n ) a ( 0 ) $2$λ$a(n)$$a(0)$$2$

λO

En esta parte del código, λel rol de es diferente. Ya dentro de un entorno recursivo, genera , la lista de todos los resultados anteriores. Luego, los resume.$[a(0),a(1),\dots,a(n-1)]$O

D₁+

Duplique la suma para su uso posterior y agregue a la segunda copia.$a(n-1)$

ÅN

Genera el primo más bajo estrictamente mayor que la suma anterior.

α

Finalmente, recupere la diferencia absoluta entre el primo calculado anteriormente y la primera copia de la suma calculada anteriormente (la suma de todas las iteraciones anteriores).

La secuencia se imprime implícitamente en STDOUT indefinidamente.

Perl 6 , 45 bytes

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

Pruébalo en línea!

Devuelve una lista perezosa que genera la secuencia sin fin.

Explicación:

Esto utiliza el operador de secuencia ...que define la secuencia 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?}

Pruébalo en línea!

Salidas indefinidamente.

JavaScript (ES6), 63 bytes

Devuelve el término , 1 indexado.$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++))()

Pruébalo en línea!

Pyth ,12 11 bytes

.f&P-;Z=-;Z

Pruébalo en línea!

Guardado 1 byte gracias a isaacg.

Genera los primeros nnúmeros de este tipo, utilizando un índice basado en 1.

.fencuentra los primeros kenteros que satisfacen un criterio particular a partir de cero. Aquí, el criterio es que el primo anterior que calculamos ;, más el número actual Z, es primo ( P). Si es así, también actualizamos el último primo calculado utilizando el comportamiento de cortocircuito de la lógica y la función ( &). .fLa variable predeterminada de Desafortunadamente es la Zque cuesta un byte en la actualización.

El truco que Isaac descubrió fue almacenar la negación del último cebado y probar eso menos el valor actual. Esto es más corto en Pyth ya que la comprobación de primalidades está sobrecargada: en números positivos encuentra la factorización prima, mientras que en números negativos determina si el valor positivo del número es primo.

Esto se traduce más o menos en:

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

Pruébalo en línea!

La salida es los primeros n términos de la secuencia.

Explicación:

Construye una lista de primos (con un 0 inicial), y al final encuentra los retornos de las diferencias entre primos sucesivos en la 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

Pruébalo en línea!

(1#1)2 2es una función que no toma entrada y genera una lista infinita.

vieja respuesta:

Haskell , 88 83 78 76 bytes

La prueba de primalidad es de esta respuesta y es mejorada por Christian Sievers (-2 bytes).

-5 bytes gracias 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

Pruébalo en línea!

05AB1E (heredado) , 12 bytes

0U[XN+DpiN,U

Pruébalo en línea!

Explicación

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

Hay un par de soluciones diferentes de 12 bytes posibles.
Este en particular podría haber sido de 10 bytes si tuviéramos una variable utilizable inicializada como 0 (en lugar de 1 y 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

Pruébalo en línea!

Siguiente función principal f () tomada de esta respuesta .

La función g () toma un número entero no negativo i y devuelve una lista de todos los elementos de la secuencia hasta ese í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

Pruébalo en línea!

1 byte gracias al Sr. Xcoder .

Haskell , 101 99 97 bytes

La función lno toma argumentos y devuelve una lista infinita. No es tan corto como el enfoque más directo de @ovs (y obviamente robé algunas partes de su respuesta), pero ¿tal vez aún sea golfable?

¡Gracias @ 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]

Pruébalo en línea!

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

Pruébalo en línea!

Esto genera el enésimo número de la secuencia (basado en 0). Al mover el printbucle, se puede modificar para generar los primeros nelementos en el mismo bytecount: ¡ Pruébelo en línea!

C (gcc) , 100 99 bytes

• Guardado un byte gracias a 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;}

Pruébalo en línea!

Japt, 17 bytes

Emite el ntérmino th, 0-indexado.

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

Intentalo