Il fattore primo più alto dei numeri vicini


13

Penso che sia più semplice spiegare questa sfida in modo sequenziale. Inizia con un numero di input N e:

  1. Trova il suo fattore primo più alto
  2. Controllare i numeri sopra e sotto N e vedere se il più alto fattore primo è più alta (cioè il più alto fattore primo di N-1 e / o N + 1 è superiore al fattore di N .
  3. Continuare a controllare i numeri più alti e / o più bassi vicini N nelle direzioni in cui aumentano i fattori più alti ( (N-2, N-3 ...) e / o (N + 2, N + 3 ...) e così su)
  4. Una volta che non ci sono fattori primi in entrambe le direzioni più alti di quelli che abbiamo già trovato, ci fermiamo e produciamo il fattore primo più alto che abbiamo incontrato.

Diamo un'occhiata a un esempio:

245ha i fattori primi 5, 7, 7. I suoi vicini sono:

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

Il fattore primo più alto sta aumentando in entrambe le direzioni, quindi dobbiamo guardare al prossimo vicino:

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

I fattori primi più alti ora stanno diminuendo in entrambe le direzioni, quindi il fattore primo più alto che abbiamo riscontrato è 61, e quindi dovrebbe essere restituito.

Un altro esempio:

Diamo un'occhiata 1024. I suoi fattori primi sono 2, 2, 2, 2, 2, 2, 2, 2, 2, 2. I fattori primi dei vicini più vicini sono:

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

Il fattore primo più elevato sta aumentando in entrambe le direzioni, da o 2verso . Diamo un'occhiata ai vicini:3141

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

Il fattore primo più alto per 1022è 73, e il fattore primo più alto per 1026è 19. Poiché 19è inferiore a quello 41che non ci interessa. Aumenta ancora per numeri inferiori a N, quindi controlleremo il prossimo in quella direzione :

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 è un numero primo e il numero più alto che abbiamo incontrato, quindi dovrebbe essere restituito.

Regole:

  • Otterrai solo positivo Nmaggiore 1e minore di 2^31-2.
  • I formati di input e output sono opzionali, ma i numeri devono essere nella base 10.
  • Dovresti continuare a cercare numeri primi più alti fintanto che il valore più alto aumenta in quella direzione. Le direzioni sono indipendenti l'una dall'altra.

Casi test:

Formato: N, highest_factor

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

Diciamo che otteniamo un fattore primo più alto di 2per N. Quindi prendiamo 5per N-1 e 61per N + 1. Quindi otteniamo 19per N-2 e 67per N + 2. Dovremmo continuare a provare numeri più bassi, da allora 19>5o fermarci, da allora 5<61? I massimi sono tenuti per lato? (Non sono sicuro che l'esempio sia matematicamente possibile.)
PurkkaKoodari,

@ Pietu1998, la domanda è più chiara ora?
Stewie Griffin,

N=2in realtà sembra essere un caso limite dal momento che 1non ha fattori primi, quindi nessun fattore primo massimo con cui possiamo confrontare per decidere se dovremmo continuare.
Jonathan Allan,

Risposte:


4

Mathematica, 82 74 byte

Grazie a Martin Ender per aver salvato 8 byte!

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

Funzione senza nome che accetta un input intero e restituisce un intero.

±n_:=#//.x_/;l[t=x+n]>l@x:>tdefinisce una funzione unaria ±che continua ad aumentare l'input intero della funzione globale nfintanto che aumenta il fattore primo più grande. (La funzione del fattore primo più grande è definita con l=FactorInteger[#][[-1,1]]&.) {±-1,±1}Pertanto applica quella funzione due volte all'intero di input, con incremento -1e di nuovo con incremento1 . Quindi, Max@@(...l...)/@...prende il più grande dei due maggiori fattori primi così trovati.

Presentazione precedente:

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

Risparmiato qualche byte evitando il @@@(e puoi usarlo l@xlì):Max@@(±n_:=#//.x_/;l[t=x+n]>l@x:>t;l=FactorInteger[#][[-1,1]]&)/@{±-1,±1}&
Martin Ender

1

Perl, 137 byte

122 byte di codice + 15 byte per -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:$_

Per eseguirlo:

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 non hai ntheoryinstallato, puoi installarlo digitando il (echo y;echo) | perl -MCPAN -e 'install ntheory'tuo terminale.


0

Rubino, 99 byte

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

Spiegazione:

  • f () è il fattore primo più alto
  • g () è la funzione che cerca i vicini in una direzione
  • applica g a (n, -1) e a (n, + 1) per cercare in entrambe le direzioni
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.