Introduzione (potrebbe essere ignorata)

Mettere tutti i numeri positivi nel suo ordine regolare (1, 2, 3, ...) è un po 'noioso, no? Quindi ecco una serie di sfide intorno alle permutazioni (rimpasto) di tutti i numeri positivi. Questa è la terza sfida di questa serie (collegamenti alla prima e alla seconda sfida).

In questa sfida, organizzeremo i numeri naturali in file di lunghezza crescente in modo tale che la somma di ogni riga sia un numero primo. Ciò che trovo davvero sorprendente di questo, è che ogni numero naturale ha un posto in questa disposizione. Nessun numero viene saltato!

Questa visualizzazione di questa disposizione è simile alla seguente:

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.

Possiamo leggere gli elementi dalle righe in questo triangolo. I primi 20 elementi sono: 1, 2, 3, 4, 5, 8, 6 , 7, 9, 15, 10, 11, 12, 13, 21, 14, 16, 17, 18, 19 ( sì, c'è una canzone del Nuovo Ordine nascosta in questa sequenza ).

Dato che si tratta di una sfida "sequenza pura", il compito è quello di produrre $a(n)$ per un dato $n$ come input, dove $a(n)$ è A162371 .

Compito

Dato un input intero $n$ , output $a(n)$ in formato intero.

$a(n)$ viene definito come il$n$ -esimo elemento del lexicographically prima permutazione dei numeri naturali tali che, se visto come un triangolo lettura per righe, per n> 1 le somme di righe sono numeri primi. Poiché la prima permutazione lessicografica dei numeri naturali inizia con 1,$a(1)$ è 1. Notare che con questa definizione$a(1) = 1$ e$a(1)$ nonènecessario essere primi. Questa è la sequenza OEISA162371.

Nota: qui si assume l'indicizzazione basata su 1; puoi utilizzare l'indicizzazione basata su 0, quindi $a(0) = 1; a(1) = 2$ , ecc. Indicare questo nella risposta se si sceglie di utilizzarlo.

Casi test

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

Regole

• Input e output sono numeri interi (il tuo programma dovrebbe almeno supportare input e output nell'intervallo da 1 a 32767)
• Input non validi (0, float, stringhe, valori negativi, ecc.) Possono causare output non previsti, errori o comportamenti (non) definiti.
• Si applicano le regole I / O predefinite .
• Sono vietate le scappatoie predefinite .
• Questo è code-golf , quindi vince la risposta più breve in byte

Gelatina , 32 byte

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

Provalo online!- molto lento come si costruisce n righe prima, per una versione più veloce che non, a 37 byte, provare questo .

Perl 6 , 80 77 byte

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

Provalo online!

Spiegazione:

{                                  }  # 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 byte

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..])!!)

Provalo online! (ha altri 2 byte perf= )

EDIT: ora utilizza l'indicizzazione basata su 0 per salvare 2 byte. Grazie @wastl per averlo sottolineato, devo averlo perso nell'OP.

È stato molto divertente scrivere! La funzione di supporto %richiede una lunghezza le un elenco di valori che può utilizzare a. Restituisce un elenco infinito di valori per la sequenza. La lunghezza è una in meno della lunghezza della riga del triangolo corrente e l'elenco è infinito e preordinato. Per prima cosa restituiamo i primi lvalori da ae poi guardiamo nel resto di a fino a trovare il primo (più piccolo) valore che rende la somma primo. Spezziamo la lista attorno a quel valore usando spane alcuni pattern matching. Ora tutto ciò che dobbiamo fare è produrre quel nuovo valore e ricorrere con la lunghezza della riga successiva l+1e i valori rimanenti in a. Per il risultato finale anteponiamo 1 (caso speciale per n = 0) e ci indicizziamo con !!.

JavaScript (ES6),  111  110 byte

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}

Provalo online!

Gelatina , 46 byte

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

Provalo online!

Timeout per il grande n on tio, ma funziona lì per tutti tranne gli ultimi due esempi.

Lua , 242 228 226 211 byte

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

Provalo online!