Creo que es más fácil explicar este desafío de manera secuencial. Comience con un número de entrada N y:

1. Encuentra su factor primo más alto
2. Verifique los números arriba y abajo de N y vea si el factor primo más alto es más alto (es decir, el factor primo más alto de N-1 y / o N + 1 es más alto que el factor de N) .
3. Continúe verificando los números más altos o más bajos vecinos de N en las direcciones donde los factores más altos están aumentando ( (N-2, N-3 ...) y / o (N + 2, N + 3 ...) y así en)
4. Una vez que no hay factores primos en ninguna dirección que sean más altos que los que ya hemos encontrado, nos detenemos y producimos el factor primo más alto que hemos encontrado.

Veamos un ejemplo:

245tiene los factores primos 5, 7, 7. Sus vecinos son:

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

El factor primo más alto está aumentando en ambas direcciones, por lo que debemos mirar al próximo vecino:

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

Los factores primos más altos ahora están disminuyendo en ambas direcciones, por lo que el factor primo más alto que hemos encontrado es 61y, por lo tanto, debe devolverse.

Otro ejemplo:

Echemos un vistazo a 1024. Sus factores primos son 2, 2, 2, 2, 2, 2, 2, 2, 2, 2. Los factores primos de sus vecinos más cercanos son:

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

El factor primo más alto está aumentando en ambas direcciones, de 2a 31o 41. Miremos a los vecinos:

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

El factor primo más alto para 1022es 73, y el factor primo más alto para 1026es 19. Como 19es más bajo de 41lo que no nos interesa. Sigue aumentando para números más pequeños que N, así que revisaremos el siguiente en esa dirección :

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 es un primo y el primo más alto que hemos encontrado, por lo que debe devolverse.

Reglas:

• Solo obtendrá positivo Nmayor 1y menor que 2^31-2.
• Los formatos de entrada y salida son opcionales, pero los números deben estar en la base 10.
• Debe continuar buscando primos más altos siempre que el valor más alto aumente en esa dirección. Las direcciones son independientes entre sí.

Casos de prueba:

Formato: N, highest_factor

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

Mathematica, 82 74 bytes

¡Gracias a Martin Ender por guardar 8 bytes!

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

Función sin nombre que toma una entrada entera y devuelve un entero.

±n_:=#//.x_/;l[t=x+n]>l@x:>tdefine una función unaria ±que sigue aumentando la entrada de enteros de la función global nsiempre que el factor primo más grande aumente. (La función de factor primo más grande se define con l=FactorInteger[#][[-1,1]]&.) {±-1,±1}Por lo tanto, aplica esa función dos veces al entero de entrada, con incremento -1y nuevamente con incremento 1. Luego,Max@@(...l...)/@... toma el mayor de los dos factores primos más grandes así encontrados.

Presentación previa:

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

Perl, 137 bytes

122 bytes de código + 15 bytes para -py -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:$_

Para ejecutarlo:

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

Si no lo ha ntheoryinstalado, puede instalarlo escribiendo (echo y;echo) | perl -MCPAN -e 'install ntheory'su terminal.

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}

Explicación:

• f () es el factor primo más alto
• g () es la función que busca vecinos en una dirección
• aplique g a (n, -1) y a (n, + 1) para buscar en ambas direcciones