El factor primo más alto de números vecinos


13

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

Digamos que obtenemos un factor primo más alto 2para N. Luego obtenemos 5para N-1 y 61para N + 1. Luego obtenemos 19N-2 y 67N + 2. ¿Deberíamos seguir intentando números más bajos, desde 19>5o parar, desde entonces 5<61? Es decir, ¿se mantienen los máximos por lado? (No estoy seguro si el ejemplo es matemáticamente posible).
PurkkaKoodari

@ Pietu1998, ¿la pregunta es más clara ahora?
Stewie Griffin

N=2en realidad parece ser un caso límite ya que 1no tiene factores primos, por lo que no hay un factor primo máximo con el que podamos comparar para decidir si debemos continuar.
Jonathan Allan

Respuestas:


4

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}})&

Ahorró algunos bytes evitando el @@@(y puede usar l@xallí):Max@@(±n_:=#//.x_/;l[t=x+n]>l@x:>t;l=FactorInteger[#][[-1,1]]&)/@{±-1,±1}&
Martin Ender

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.


0

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
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.