Introducción (puede ser ignorado)

Poner todos los números positivos en su orden regular (1, 2, 3, ...) es un poco aburrido, ¿no? Así que aquí hay una serie de desafíos en torno a las permutaciones (reorganizaciones) de todos los números positivos. Este es el tercer desafío de esta serie (enlaces al primer y segundo desafío).

En este desafío, organizaremos los números naturales en filas de longitud creciente de tal manera que la suma de cada fila sea primo. Lo que me parece realmente sorprendente de esto es que cada número natural tiene un lugar en este arreglo. ¡No se saltan números!

Esta visualización de este arreglo se ve así:

row             numbers             sum
1                  1                  1
2                2   3                5
3              4   5   8             17
4            6   7   9  15           37
5          10 11  12  13  21         67
6        14  16 17  18  19  23      107
etc.

Podemos leer los elementos de las filas en este triángulo. Los primeros 20 elementos son: 1, 2, 3, 4, 5, 8, 6 , 7, 9, 15, 10, 11, 12, 13, 21, 14, 16, 17, 18, 19 ( sí, hay una canción de New Order oculta en esta secuencia ).

Como se trata de un desafío de "secuencia pura", la tarea es generar $a(n)$ para un $n$ dado como entrada, donde $a(n)$ es A162371 .

Tarea

Dada una entrada entera $n$ , salida $a(n)$ en formato entero.

$a(n)$ se define como el$n$ -ésimo elemento de la lexicográficamente más temprana permutación de los números naturales de tal manera que, cuando se ve como un triángulo leído por filas, para n> 1 las sumas de filas son números primos. Desde la primera permutación lexicográfica de los números naturales comienza con 1,$a(1)$ es 1. Tenga en cuenta que en esta definición$a(1) = 1$ y$a(1)$ seno serequiere que sea primo. Esta es la secuencia OEISA162371.

Nota: aquí se supone una indexación basada en 1; puede usar indexación basada en 0, entonces $a(0) = 1; a(1) = 2$ , etc. Mencione esto en su respuesta si elige usar esto.

Casos de prueba

Input | Output
---------------
1     |  1
5     |  5
20    |  19
50    |  50
78    |  87
123   |  123
1234  |  1233
3000  |  3000
9999  |  9999
29890 |  29913

Reglas

• La entrada y la salida son enteros (su programa al menos debe admitir entradas y salidas en el rango de 1 hasta 32767)
• La entrada no válida (0, flotantes, cadenas, valores negativos, etc.) puede generar salidas imprevistas, errores o un comportamiento (no) definido.
• Se aplican las reglas de E / S predeterminadas .
• Las lagunas predeterminadas están prohibidas.
• Este es el código de golf , por lo que las respuestas más cortas en bytes ganan

Jalea , 32 bytes

;®»ṀƊSÆn_S
ẎṀ©+LRḟẎḣL;Ç$ṭ
1Ç¡Fị@

Pruébalo en línea! - Muy lento, ya que construye n filas primero, para una versión más rápida que no lo hace, a 37 bytes, intente esto .

Perl 6 , 80 77 bytes

{({$!=@_;+(1...{$_∉$!&&(|$!,$_).rotor(1..*).one.sum.is-prime-1})}...*)[$_]}

Pruébalo en línea!

Explicación:

{                                  }  # Anonymous code block
 (                        ...*)[$_]   # Index into the infinite sequence
  {                      }   # Where each element is
   $!=@_;  # Save the list of previous elements into $!
   +(1...{             })    # Return the first number that
          $_∉$!         # Has not appeared in the list so far
          &&            # And
          (|$!,$_)      # The new sequence
          .rotor(1..*)  # Split into rows of increasing length
                        # And ignoring incomplete rows
          .one          # Have exactly one row
          .sum          # Where the sum
          .is-prime-1   # Is not prime (i.e. just the first row)

Haskell , 122 120 bytes

import Data.Numbers.Primes
l%a|(p,q)<-splitAt l a,(s,k:t)<-span(not.isPrime.(+sum p))q=p++k:(l+1)%(s++t)
((1:1%[2..])!!)

Pruébalo en línea! (tiene 2 bytes adicionales para f=)

EDITAR: ahora usa indexación basada en 0 para guardar 2 bytes. Gracias @wastl por señalar eso, debo haberlo perdido en el OP.

¡Fue muy divertido escribirlo! La función auxiliar %toma una longitud ly una lista de valores que puede usar a. Devuelve una lista infinita de valores para la secuencia. La longitud es uno menos que la longitud de la fila triangular actual y la lista es infinita y ordenada previamente. Primero solo damos los primeros lvalores ay luego miramos el resto de a hasta encontrar el primer valor (el más pequeño) que hace que la suma sea prima. Desglosamos la lista alrededor de ese valor usando spany alguna coincidencia de patrones. Ahora todo lo que tenemos que hacer es obtener ese nuevo valor y repetir con la siguiente longitud de línea l+1y los valores restantes en a. Para el resultado final, anteponemos 1 (caso especial para n = 0) y lo indexamos con !!.

JavaScript (ES6),  111  110 bytes

n=>{for(g=n=>{for(d=n;n%--d;);},i=l=0;i--||(k=s=0,i=l++),n--;g[k]=s+=r=k)for(;g[++k]|g(!i*++s)|d>1;);return r}

Pruébalo en línea!

Jalea , 46 bytes

S©‘æR®Ḥ‘¤_®ḟ;F¥Ṃ
FLḤRḟFḣ0ịLƊ;祵W
1;Ç$⁸½Ḥ¤¡Fị@

Pruébalo en línea!

Se agota el tiempo de espera para n grande en tio, pero funciona allí para todos excepto los dos últimos ejemplos

Lua , 242 228 226 211 bytes

s={}u={}i=0 n=0+...while i<n do
n=n-i
x,S=1,0
for j=1,i do
while u[x]do x=x+1 end
s[j]=x
S=S+x
u[x]=0
end
while u[x]or p do
x=x+1
d=S+x
p=F
for c=2,d-1 do
p=p or d%c<1
end
end
i=i+1
s[i]=x
u[x]=0
end
print(s[n])

Pruébalo en línea!