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.