Ich denke, es ist am einfachsten, diese Herausforderung nacheinander zu erklären. Beginnen Sie mit einer Eingabenummer N und:

1. Finden Sie den höchsten Primfaktor
2. Überprüfen Sie die Zahlen über und unter N und prüfen Sie, ob der höchste Primfaktor höher ist (dh der höchste Primfaktor von N-1 und / oder N + 1 ist höher als der Faktor von N) .
3. Überprüfen Sie weiterhin höhere und / oder niedrigere Zahlen neben N in den Richtungen, in denen die höchsten Faktoren zunehmen ( (N-2, N-3 ...) und / oder (N + 2, N + 3 ...) und so weiter auf)
4. Sobald es in keiner Richtung Primfaktoren gibt, die höher sind als die, die wir bereits gefunden haben, stoppen wir und geben den höchsten Primfaktor aus, auf den wir gestoßen sind.

Schauen wir uns ein Beispiel an:

245hat die Primfaktoren 5, 7, 7. Seine Nachbarn sind:

244 -> 2,  2,  61
245 -> 5,  7,  7
246 -> 2,  3,  41

Der höchste Primfaktor steigt in beide Richtungen, also müssen wir uns den nächsten Nachbarn ansehen:

243 -> 3,   3,  3,  3,  3
244 -> 2,   2,  2,  61
245 -> 5,   7,  7
246 -> 2,   3,  41
247 -> 13,  19

Die höchsten Primfaktoren nehmen nun in beide Richtungen ab, so dass der höchste Primfaktor, den wir angetroffen haben, ist 61und daher zurückgegeben werden sollte.

Ein anderes Beispiel:

Schauen wir uns an 1024. Seine Hauptfaktoren sind 2, 2, 2, 2, 2, 2, 2, 2, 2, 2. Die Hauptfaktoren seiner nächsten Nachbarn sind:

1023 -> 3, 11, 31
1024 -> 2,  2,  2,  2,  2,  2,  2,  2,  2,  2
1025 -> 5,  5, 41

Die höchsten Primfaktoren nehmen in beide Richtungen zu, von 2bis 31oder 41. Schauen wir uns die Nachbarn an:

1022 -> 2, 7,  73
1023 -> 3, 11, 31
1024 -> 2,  2,  2,  2,  2,  2,  2,  2,  2,  2
1025 -> 5,  5, 41
1026 -> 2,  3,  3, 19

Der höchste Primfaktor für 1022ist 73und der höchste Primfaktor für 1026ist 19. Da 19ist niedriger als 41wir nicht daran interessiert sind. Bei Zahlen unter N nimmt die Zahl immer noch zu, daher überprüfen wir die nächste Zahl in dieser Richtung :

1021 -> 1021
1022 -> 2, 7,  73
1023 -> 3, 11, 31
1024 -> 2,  2,  2,  2,  2,  2,  2,  2,  2,  2
1025 -> 5,  5, 41
1026 -> 2,  3,  3, 19

1021 ist eine Primzahl und die höchste Primzahl, auf die wir gestoßen sind. Sie sollte daher zurückgegeben werden.

Regeln:

• Sie werden nur Ngrößer 1und kleiner als positiv 2^31-2.
• Eingabe- und Ausgabeformate sind optional, die Zahlen müssen sich jedoch in der Basis 10 befinden.
• Sie sollten weiter nach höheren Primzahlen suchen, solange der höchste Wert in diese Richtung steigt. Die Richtungen sind voneinander unabhängig.

Testfälle:

Format: N, highest_factor

2, 3
3, 3
6, 7
8, 11
24, 23 
1000, 997
736709, 5417 
8469038, 9431

Mathematica, 82 74 Bytes

Vielen Dank an Martin Ender für das Speichern von 8 Bytes!

Max@@(±n_:=#//.x_/;l[t=x+n]>l@x:>t;l=FactorInteger[#][[-1,1]]&)/@{±-1,±1}&

Unbenannte Funktion, die eine Ganzzahleingabe und eine Ganzzahl zurückgibt.

±n_:=#//.x_/;l[t=x+n]>l@x:>tdefiniert eine unäre Funktion, ±die die Ganzzahleingabe der globalen Funktion nso lange erhöht, wie der größte Primfaktor zunimmt. (Die Funktion mit dem größten Primfaktor wird mit definiert l=FactorInteger[#][[-1,1]]&.) Diese Funktion wird {±-1,±1}daher zweimal mit Inkrement -1und erneut mit Inkrement auf die ganze Eingangszahl angewendet 1. Nimmt man Max@@(...l...)/@...dann den größeren der beiden so gefundenen größten Primfaktoren.

Vorherige Einreichung:

Max@@(l=FactorInteger[#][[-1,1]]&)/@(#//.x_/;l[t=x+#2]>l[x]:>t&@@@{{#,-1},{#,1}})&

Perl, 137 Bytes

122 Byte Code + 15 Byte für -pund -Mntheory=:all.

sub f{$t=(factor$_+pop)[-1]}$i=$j=1;while($i|$j){f++$c;($i&=$t>$h)&&($h=$t);f-$c;($j&=$t>$l)&&($l=$t)}$_=$h>$l?$h:$l?$l:$_

Um es auszuführen:

perl -pMntheory=:all -e 'sub f{$t=(factor$_+pop)[-1]}$i=$j=1;while($i|$j){f++$c;($i&=$t>$h)&&($h=$t);f-$c;($j&=$t>$l)&&($l=$t)}$_=$h>$l?$h:$l?$l:$_' <<< 736709

Wenn Sie es noch nicht ntheoryinstalliert haben, können Sie es installieren, indem Sie (echo y;echo) | perl -MCPAN -e 'install ntheory'Ihr Terminal eingeben .

Ruby, 99 Bytes

->n{f=->n{i=2;n%i<1?n/=i:i+=1while i<n;n};g=->s,z{s+=z while f[s+z]>b=f[s];b};[g[n,1],g[n,-1]].max}

Erläuterung:

• f () ist der höchste Primfaktor
• g () ist die Funktion, die Nachbarn in eine Richtung sucht
• wende g auf (n, -1) und auf (n, + 1) an, um in beide Richtungen zu suchen