Einleitung (kann ignoriert werden)

Es ist ein bisschen langweilig, alle positiven Zahlen in der regulären Reihenfolge (1, 2, 3, ...) anzuordnen, nicht wahr? Hier ist also eine Reihe von Herausforderungen im Zusammenhang mit Permutationen (Umformungen) aller positiven Zahlen. Dies ist die dritte Herausforderung in dieser Reihe (Links zur ersten und zweiten Herausforderung).

In dieser Herausforderung ordnen wir die natürlichen Zahlen in Reihen mit zunehmender Länge so an, dass die Summe jeder Reihe eine Primzahl ist. Was ich an diesem Arrangement wirklich erstaunlich finde, ist, dass jede natürliche Zahl einen Platz in diesem Arrangement hat. Es werden keine Nummern übersprungen!

Diese Visualisierung dieser Anordnung sieht folgendermaßen aus:

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.

Wir können die Elemente aus den Zeilen in diesem Dreieck lesen. Die ersten 20 Elemente sind: 1, 2, 3, 4, 5, 8, 6 , 7, 9, 15, 10, 11, 12, 13, 21, 14, 16, 17, 18, 19 ( ja, das gibt es ein in dieser Sequenz verstecktes New Order-Lied ).

Da dies eine „reine Sequenz“ Herausforderung ist, die Aufgabe zu Ausgang ist für ein gegebenen als Eingabe, wobei ist A162371 .$a(n)$$n$$a(n)$

Aufgabe

Eine ganze Zahl Eingang gegebenen , Ausgabe in Ganzzahl - Format.$n$$a(n)$

$a(n)$ ist definiert als das te Element der lexikographisch frühesten Permutation der natürlichen Zahlen, so dass bei Betrachtung als von Zeilen gelesenes Dreieck für n> 1 die Zeilensummen Primzahlen sind. Da die erste lexikographische Permutation der natürlichen Zahlen beginnen bei 1, 1 ist zu beachten , dass durch diese Definition und ist nicht prim zu sein , erforderlich ist . Dies ist die OEIS-Sequenz A162371 .$n$$a(1)$$a(1) = 1$$a(1)$

Hinweis: Hier wird eine 1-basierte Indizierung angenommen. Sie können eine 0-basierte Indizierung verwenden, also usw. Bitte erwähnen Sie dies in Ihrer Antwort, wenn Sie dies verwenden möchten.$a(0) = 1; a(1) = 2$

Testfälle

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

Regeln

• Eingabe und Ausgabe sind ganze Zahlen (Ihr Programm sollte mindestens Eingabe und Ausgabe im Bereich von 1 bis 32767 unterstützen)
• Ungültige Eingaben (0, Gleitkommazahlen, Zeichenfolgen, negative Werte usw.) können zu unvorhergesehenen Ausgaben, Fehlern oder (un) definiertem Verhalten führen.
• Es gelten die Standard- E / A-Regeln .
• Standardlücken sind verboten.
• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes

Jelly , 32 Bytes

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

Probieren Sie es online! - sehr langsam, da zuerst n Zeilen erstellt werden, für eine schnellere Version, die dies bei 37 Bytes nicht versucht .

Perl 6 , 80, 77 Bytes

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

Probieren Sie es online!

Erläuterung:

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

Probieren Sie es online! (hat 2 zusätzliche Bytes für f=)

BEARBEITEN: Verwendet jetzt die 0-basierte Indizierung, um 2 Bytes zu sparen. Danke @wastl für den Hinweis, ich muss es im OP verpasst haben.

Das war sehr lustig zu schreiben! Die Hilfsfunktion %benötigt eine Länge lund eine Liste von Werten, die sie verwenden kann a. Es wird eine unendliche Liste von Werten für die Sequenz zurückgegeben. Die Länge ist um eins kürzer als die Länge der aktuellen Dreieckszeile, und die Liste ist unendlich und vorsortiert. Zuerst geben wir nur die ersten lWerte aus aund sehen dann den Rest von a durch, bis wir den ersten (kleinsten) Wert finden, der die Summe zur Primzahl macht. Wir teilen die Liste um diesen Wert mit spanund einigen Musterübereinstimmungen. Jetzt müssen wir nur noch diesen neuen Wert ermitteln und mit der nächsten Zeilenlänge l+1und den verbleibenden Werten in wiederkehren a. Für das Endergebnis stellen wir 1 voran (Sonderfall für n = 0) und indizieren darin mit !!.

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}

Probieren Sie es online!

Jelly , 46 Bytes

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

Probieren Sie es online!

Zeitüberschreitung für großes n auf tio, funktioniert aber dort für alle außer den letzten beiden Beispielen.

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

Probieren Sie es online!