Eu acho que é mais fácil explicar esse desafio de maneira seqüencial. Comece com um número de entrada N e:

1. Encontre seu maior fator primo
2. Verificar números acima e abaixo N e ver se o máximo factor principal é maior (ou seja, o maior factor primo de N-1 e / ou N + 1 é maior do que o factor de N .
3. Continue verificando números mais altos e / ou mais baixos vizinhos de N nas direções em que os fatores mais altos estão aumentando ( (N-2, N-3 ...) e / ou (N + 2, N + 3 ...) e assim em)
4. Uma vez que não existem fatores primos em qualquer direção que sejam mais altos do que os que já encontramos, paramos e produzimos o fator primo mais alto que encontramos.

Vejamos um exemplo:

245tem os principais fatores 5, 7, 7. Seus vizinhos são:

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

O fator primordial mais alto está aumentando em ambas as direções, portanto, devemos olhar para o próximo vizinho:

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

Os fatores primos mais altos agora estão diminuindo em ambas as direções; portanto, o fator primo mais alto que encontramos é 61e deve, portanto, ser retornado.

Outro exemplo:

Vamos olhar 1024. Seus principais fatores são 2, 2, 2, 2, 2, 2, 2, 2, 2, 2. Os principais fatores de seus vizinhos mais próximos são:

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

O fator primordial mais alto está aumentando em ambas as direções, de 2para 31ou 41. Vamos olhar para os vizinhos:

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

O maior fator primo para 1022é 73e o maior fator primo para 1026é 19. Uma vez que 19é mais baixo do 41que não estamos interessados. Ainda está aumentando para números menores que N, portanto, verificaremos o próximo nessa direção :

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 é o prime e o prime mais alto que encontramos, portanto, ele deve ser retornado.

Regras:

• Você só será positivo Nmaior que 1e menor que 2^31-2.
• Os formatos de entrada e saída são opcionais, mas os números devem estar na base 10.
• Você deve continuar procurando números primos mais altos, desde que o valor mais alto esteja aumentando nessa direção. As direções são independentes uma da outra.

Casos de teste:

Formato: N, highest_factor

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

Mathematica, 82 74 bytes

Agradecemos a Martin Ender por economizar 8 bytes!

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

Função sem nome, recebendo uma entrada inteira e retornando um número inteiro.

±n_:=#//.x_/;l[t=x+n]>l@x:>tdefine uma função unária ±que continua aumentando a entrada inteira da função global nenquanto o maior fator principal estiver aumentando. (A função de fator principal maior é definida com l=FactorInteger[#][[-1,1]]&.), {±-1,±1}Portanto, aplica essa função duas vezes ao número inteiro de entrada, com incremento -1e novamente com incremento 1. Então, Max@@(...l...)/@...leva o maior dos dois maiores fatores primos encontrados.

Submissão anterior:

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 -pe -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 executá-lo:

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

Se você não tiver ntheoryinstalado, poderá instalá-lo digitando (echo y;echo) | perl -MCPAN -e 'install ntheory'seu 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}

Explicação:

• f () é o fator principal mais alto
• g () é a função que procura vizinhos em uma direção
• aplique g a (n, -1) e a (n, + 1) para pesquisar nas duas direções