Angenommen, wir beginnen mit der unendlichen Liste der Primzahlen:

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, ...

Dann nehmen wir die absoluten Unterschiede zwischen jedem Zahlenpaar wiederholt:

[1, 2, 2, 4, 2, 4, 2, 4, 6, 2, 6, 4, 2, 4, 6, 6, 2, 6, 4, ...
[1, 0, 2, 2, 2, 2, 2, 2, 4, 4, 2, 2, 2, 2, 0, 4, 4, 2, ...
[1, 2, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 2, 4, 0, 2, ...
[1, 2, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 2, 2, 4, 2, ...

Beachten Sie, dass die führende Zahl jedes Mal 1 ist. Gilbreaths Vermutung ist die Vorhersage, dass dies für immer der Fall ist.

Die führende Zahl würde nur dann aufhören, eine 1 zu sein, wenn die nächste Zahl weder eine 0 noch eine 2 wäre. Die zweite Zahl würde nur dann keine 0 oder eine 2 sein, wenn die Zahl danach weder eine war 0 noch eine 2. Und so weiter.

Der Index der frühesten Zahl mit Ausnahme der führenden 1, die weder eine 0 noch eine 2 ist, kann zwischen zwei aufeinanderfolgenden Folgen niemals um mehr als 1 abfallen. Diese Tatsache wurde verwendet, um eine sehr starke Untergrenze festzulegen, wenn eine Sequenz, wenn überhaupt, möglicherweise keine 1 als erstes Element hat.

In dieser Herausforderung erhalten Sie den Index einer Sequenz und müssen den Index der ersten Zahl in der Sequenz ausgeben, die nicht die führende 1 und keine 0 oder 2 ist.

Zum Beispiel in der vierten absoluten Differenzsequenz oben:

[1, 2, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 2, 2, 4, 2, ...

Der erste Eintrag, der weder eine Null noch eine Zwei ist, mit Ausnahme des ersten Eintrags, ist die 15. Position mit einem Index von 14 Nullen. Wenn die Eingabe also 4 wäre, würden Sie 14 ausgeben.

Für Eingaben von 1 bis 30 sollten die Ausgaben sein:

[3, 8, 14, 14, 25, 24, 23, 22, 25, 59, 98, 97, 98, 97, 174, 176, 176, 176, 176, 291, 290, 289, 740, 874, 873, 872, 873, 872, 871, 870]

Dies ist OEIS A000232 .

Dies setzt voraus, dass Sie 1 indizierte Eingänge und 0 indizierte Ausgänge haben. Sie können Ihre Eingaben und Ausgaben beginnend mit beliebigen konstanten Ganzzahlen indizieren, solange Sie den Bereich der Eingaben akzeptieren können, der allen Sequenzen entspricht.

Anforderungen: Ihre Lösung darf bei einer Eingabe von bis zu 30 höchstens 1 Minute lang ausgeführt werden. Wenn sie nah genug ist, dass sie von den Computerspezifikationen abhängt, ist sie zulässig.

Kürzester Code gewinnt.

Gelee , 17 Bytes

ÆNạ2\Ḋ¿Ḣ’Ị
R‘ÇпL

Probieren Sie es online!

Eingabe ist 2-indiziert. Die Ausgabe ist 1-indiziert.

Bei TIO dauern alle Testfälle insgesamt 22.309 s.

Mathematica, 66 Bytes

(For[z=1,Last@Nest[Abs@*Differences,Array[Prime,z+#],#]<3,z++];z)&

Reine Funktion, die eine positive Ganzzahl als Argument verwendet und eine 1-indizierte Ganzzahl zurückgibt. Nest[Abs@*Differences,Array[Prime,z+#],#]berechnet die #iterierte absolute Differenzliste der Liste der ersten z+#Primzahlen. For[z=1,Last@...<3,z++]Schleift diese Berechnung, bis mindestens das letzte Element der resultierenden Liste vorliegt 3, und wird dann zausgegeben. (Beachten Sie, dass die Richtigkeit des Algorithmus Gilbreaths Vermutung voraussetzt!)

Pyth , 32 Bytes

-l.W>3h.WtHaVZtZ>QH+ZfP_TheZ.fP_

Probieren Sie es online!

Verwendet 2-Indizierung.

MATL , 18 Bytes

`@:YqG:"d|]3<A}@G-

Eingang und Ausgang sind 1-basiert. In TIO dauert es für jeden Testfall weniger als 40 Sekunden.

Probieren Sie es online!

Erläuterung

Dadurch werden längere Anfangssequenzen von Primzahlen versucht, bis die iterierten absoluten aufeinanderfolgenden Differenzen mindestens einen Wert ergeben, der übersteigt 2.

`        % Do... while loop
  @:Yq   %   Array of first k primes, where k is iteration index
  G:"    %   Do this as many times as the input
    d|   %     Absolute value of consecutive differences
  ]      %   End
  3<A    %   Are they all less than 3? This is the loop condition
}        % Finally (execute before exiting loop)
  @G-    %   Push last iteration index minus input. This is the output
         % End (implicit). Continue with next iteration if top of stack is true
         % Display (implicit)

Perl 6 , 136 120 Bytes

{->\i,\n{i??&?BLOCK(i-1,lazy
n.rotor(2=>-1).map: {abs .[1]-.[0]})!!1+n.skip.first:
:k,none 0,2}($_,grep &is-prime,2..*)}

Ungolfed:

{   # Anonymous function with argument in $_
    sub f(\i, \n) {  # Recursive helper function
        if i != 0 {  # If we're not done,
            # Recurse on the absolute differences between adjacent entries:
            f(i - 1, lazy n.rotor(2 => -1).map: { abs .[1] - .[0] });
        } else {
            # Otherwise, return the first index after 0
            # where the value is neither 0 nor 2.
            1 + n.skip.first: :k, none 0, 2;
        }
    }
    # Call the helper function with the argument passed to the top-level
    # anonymous function (the recursion depth), and with the prime numbers
    # as the initial (infinite, lazy) list:
    f($_, grep &is-prime, 2 .. *);
}

Bei einer Eingabe von 30 läuft die Funktion auf meinem bescheidenen Laptop in etwa vier Sekunden.

... das 1,4 Sekunden nach dem Upgrade meiner sieben Monate alten Perl 6-Installation wird (was mir auch die skipMethode gibt, mit der ich mehrere Bytes von meiner ersten Lösung entfernen kann). Alle Testfälle von 1 bis 30 dauern etwa zehn Sekunden.

Haskell , 94 Bytes

f(a:b:r)=abs(a-b):f(b:r)
length.fst.span(<3).(iterate f[n|n<-[2..],all((>0).mod n)[2..n-1]]!!)

Probieren Sie es online! Die letzte Zeile ist eine anonyme Funktion. Binde zB an gund rufe gerne an g 4. Alle Testfälle zusammen dauern unter TIO weniger als 2 Sekunden.

Wie es funktioniert

[n|n<-[2..],all((>0).mod n)[2..n-1]]Erzeugt eine unendliche Liste von Primzahlen.
f(a:b:r)=abs(a-b):f(b:r)ist eine Funktion, die die absoluten Unterschiede der Elemente einer unendlichen Liste ergibt. Gegeben eine Zahl n, (iterate f[n|n<-[2..],all((>0).mod n)[2..n-1]]!!)gilt f nmal für die Liste der Primzahlen. length.fst.span(<3)berechnet die Länge des Präfixes der resultierenden Liste, in der die Elemente kleiner sind 3.

Axiom, 289 Bytes

g(n:PI):PI==(k:=n*10;c:List NNI:=[i for i in 1..(k quo 2)|prime?(i)];repeat(a:=concat(c,[i for i in (k quo 2+1)..k|prime?(i)]);j:=0;c:=a;repeat(j=n=>break;j:=j+1;b:=a;a:=[abs(b.(i+1)-b.i)for i in 1..(#b-1)]);j:=2;repeat(j>#a=>break;a.j~=2 and a.j~=1 and a.j~=0=>return j-1;j:=j+1);k:=k*2))

entgolfen und testen

f(n:PI):PI==
  k:=n*10
  c:List NNI:=[i for i in 1..(k quo 2)|prime?(i)]
  repeat
    a:=concat(c,[i for i in (k quo 2+1)..k|prime?(i)])
    j:=0;c:=a
    repeat
       j=n=>break
       j:=j+1
       b:=a
       a:=[abs(b.(i+1)-b.i)  for i in 1..(#b-1)]
    j:=2
    repeat
       j>#a=>break
       a.j~=2 and a.j~=1 and a.j~=0 => return j-1
       j:=j+1
    k:=k*2

(4) -> [g(i)  for i in 1..30]
   (4)
   [3, 8, 14, 14, 25, 24, 23, 22, 25, 59, 98, 97, 98, 97, 174, 176, 176, 176,
    176, 291, 290, 289, 740, 874, 873, 872, 873, 872, 871, 870]

Wenn die Lösung nicht gefunden wird, erweitern Sie die Primliste von 2 * x in einer Schleife und berechnen Sie alle verbleibenden Listen neu. 3 Sekunden für Find g (30)