Dato un numero intero n >= 2, genera l'esponente più grande nella sua scomposizione in fattori primi. Questa è la sequenza OEIS A051903 .

Esempio

Let n = 144. La sua prima fattorizzazione è 2^4 * 3^2. Il più grande esponente è 4.

Casi test

2 -> 1
3 -> 1
4 -> 2
5 -> 1
6 -> 1
7 -> 1
8 -> 3
9 -> 2
10 -> 1
11 -> 1
12 -> 2
144 -> 4
200 -> 3
500 -> 3
1024 -> 10
3257832488 -> 3

— Mego
fonte

Sandbox

— Mego

8

05AB1E , 2 byte

ÓZ

Provalo online!

Come?

Ó   exponents of prime factors
 Z  maximum

— Uriel
fonte

7

Python 2 , 62 57 56 byte

lambda n:max(k%n-n%(k/n+2)**(k%n)*n for k in range(n*n))

Provalo online!

— Dennis
fonte

Versione ricorsiva:f=lambda n,k=0:max(k%n-n%(k/n+2)**(k%n)*n,k<n**2and f(n,k+1))

— Erik the Outgolfer,

6

Gelatina , 3 byte

ÆEṀ

Provalo online!

ÆEṀ - Programma completo / collegamento Monadic.

ÆE - Matrice di esponenti della scomposizione in fattori primi.
  Ṁ - Massimo.

_{Questo funziona anche in M . Provalo online!}

— Mr. Xcoder
fonte

5

Haskell , 61 60 50 48 46 byte

-2 byte grazie a xnor

f n=maximum[a|k<-[2..n],a<-[1..n],n`mod`k^a<1]

Provalo online!

45 byte con un'importazione:

import NumberTheory
maximum.map snd.factorize

Provalo online!

— H.PWiz
fonte

Il 0^è carino, ma è più breve per controllare solo la condizione di un valore booleano.

— xnor

4

Ohm v2 , 2 byte

n↑

Provalo online!

Spiegazione?

No.

— totallyhuman
fonte

4

Python 2 , 78 byte

n=input()
e=m=0
f=2
while~-n:q=n%f<1;f+=1-q;e=q*-~e;m=max(m,e);n/=f**q
print m

Provalo online!

-5 grazie agli ovs .

Questa risposta non fa i primi controlli. Invece, sfrutta il fatto che l'esponente più alto di un fattore primo sarà maggiore o uguale all'esponente di qualsiasi altro fattore in qualsiasi fattorizzazione di un numero.

— Erik the Outgolfer
fonte

81 byte

— ovs

@ovs grazie, mi mancava che mentre stavo provando a pubblicare rapidamente

— Erik the Outgolfer,

78 byte

— ovs

@ovs finalmente, mi sono rilassato dall'if / altro, grazie

— Erik the Outgolfer,

4

Japt `-h` , 9 7 byte

k ü mÊn

Provalo

k ü mÊn     :Implicit input of integer
k           :Prime factors
  ü         :Group by value
    m       :Map
     Ê      :  Length
      n     :Sort
            :Implicit output of last element

— ispido
fonte

2

Credo che questo dovrebbe essere molto più breve, forse dovrei aggiungere un built-in per le coppie di esponenti primi ...

— ETHproductions

Perché utilizzare "ü: Raggruppa per valore" anziché la funzione di ordinamento? Sì, forse perché l'ordinamento restituisce un array ma abbiamo bisogno di un array di array ...

— RosLuP

1

@RosLuP, esattamente; ücrea sotto array di valori uguali. Si fa anche ordinare dal primo valore, ma che non è qui rilevante.

— Shaggy

3

Mathematica, 27 byte

Max[Last/@FactorInteger@#]&

Provalo online!

— J42161217
fonte

Alternativamente, Max@@Last/@FactorInteger@#&. Purtroppo questo non salva alcun byte.

— totalmente umano il

3

MATL , 4 byte

YFX>

Provalo online!

       % implicit input
YF     % Exponents of prime factors
X>     % maximum
       % implicit output

— Giuseppe
fonte

3

Brachylog , 5 byte

ḋḅlᵐ⌉

Provalo online!

Spiegazione

ḋ          Prime decomposition
 ḅ         Group consecutive equal values
  lᵐ       Map length
    ⌉      Maximum

— Fatalize
fonte

3

Buccia , 5 byte

▲mLgp

Provalo online!

p - Ottiene i fattori primi.
g - Raggruppa i valori adiacenti.
mL - Ottiene le lunghezze di ciascun gruppo.
▲ - Massimo.

— Mr. Xcoder
fonte

2

APL (Dyalog) , 19 byte

⎕CY'dfns'
⌈/1↓2pco⎕

Provalo online!

Come?

2pco⎕ - Matrice 2D di fattori primi ed esponenti

1↓ - rilasciare i fattori

⌈/ - massimo

— Uriel
fonte

2

Javascript 54 byte

* assumendo uno stack infinito (come nelle sfide del code-golf)

P=(n,i=2,k)=>i>n?k:n%i?k>(K=P(n,i+1))?k:K:P(n/i,i,-~k)

console.log(P(2 )== 1)
console.log(P(3 )== 1)
console.log(P(4 )== 2)
console.log(P(5 )== 1)
console.log(P(6 )== 1)
console.log(P(7 )== 1)
console.log(P(8 )== 3)
console.log(P(9 )== 2)
console.log(P(10 )== 1)
console.log(P(11 )== 1)
console.log(P(12 )== 2)
console.log(P(144 )== 4)
console.log(P(200 )== 3)
console.log(P(500 )== 3)
console.log(P(1024 )== 10)
//console.log(P(3257832488 )== 3)

Espandi frammento

— DanielIndie
fonte

2

PARI / GP, 24 byte

n->vecmax(factor(n)[,2])

Se non conto la n->parte, è di 21 byte.

— Jeppe Stig Nielsen
fonte

2

Ottava , 25 byte

@(n)[~,m]=mode(factor(n))

Provalo online!

Spiegazione

factorproduce la matrice di esponenti primi (possibilmente ripetuti) La seconda uscita di modefornisce il numero di volte in cui appare la modalità (cioè la voce più ripetuta).

— Luis Mendo
fonte

1

Pyth , 7 byte

eShMr8P

Provalo qui.

— Erik the Outgolfer
fonte

Alternative: eS/LPQP(7 byte), eSlM.gkP(8 byte).

— Mr. Xcoder,

1

Python 2 , 90 84 byte

f=lambda n,i=2,l=[0]:(n<2)*max(map(l.count,l))or n%i and f(n,i+1,l)or f(n/i,2,l+[i])

Provalo online!

— OVS
fonte

1

Gaia , 4 byte

ḋ)⌠)

Provalo online!

ḋ- Calcola la scomposizione in fattori primi come coppie [primo, esponente] .
- ⌠ - Mappa e raccogli il risultato con il valore massimo.
- ) - Ultimo elemento (esponente).
- ) - Ultimo elemento (esponente massimo)

Gaia , 4 byte

ḋ)¦⌉

Provalo online!

ḋ- Calcola la scomposizione in fattori primi come coppie [primo, esponente] .
- )¦ - Mappa con l'ultimo elemento (esponente).
- ⌉ - Ottiene l'elemento massimo.

— Mr. Xcoder
fonte

1

MY , 4 byte

ωĖ⍐←

Provalo online!

Spiegazione?

ωĖ⍐←
ω    = argument
 Ė   = prime exponents
  ⍐  = maximum
   ← = output without a newline

— Zaccaria
fonte

1

Ottava : 30 byte

@(x)max(histc(a=factor(x),a));

a=factor(x)restituisce un vettore contenente i fattori primi di x. Questo è un vettore ordinato in ordine crescente in cui la moltiplicazione di tutti i numeri in si factor(x)rende xtale che ogni numero nel vettore è primo.
histc(...,a)calcola un istogramma sul vettore del fattore primo in cui i bin sono i fattori primi. L'istogramma conta quante volte abbiamo visto ciascun numero primo producendo così l'esponente di ciascun numero primo. Possiamo imbrogliare qui un po 'perché anche se factor(x)restituirà numeri o bin duplicati, solo uno dei bin acquisirà il numero totale di volte che vediamo un numero primo.
max(...) restituisce quindi l'esponente più grande.

Provalo online!

— rayryeng - Ripristina Monica
fonte

1

Alice , 17 byte

/o
\i@/w].D:.t$Kq

Provalo online!

Spiegazione

/o
\i@/...

Questo è solo un framework per programmi aritmetici semplici con I / O decimale. Il ...è il vero programma, che ha già l'ingresso nello stack e lascia l'uscita in cima alla pila.

Alice in realtà ha dei built-in per ottenere la scomposizione in fattori primi di un numero intero (anche con coppie di esponenti primi), ma il più breve che ho escogitato usando quelli è di 10 byte più lungo di questo.

Invece l'idea è che dividiamo ripetutamente una copia di ciascun fattore primo distinto dall'input, fino a raggiungere 1 . Il numero di passaggi necessari è uguale al più grande esponente principale. Abuseremo della testina come variabile contatore.

w      Remember the current IP position. Effectively starts a loop.
  ]      Move the tape head to the right, which increments our counter.
  .D     Duplicate the current value, and deduplicate its prime factors.
         That means, we'll get a number which is the product of the value's
         unique prime factors. For example 144 = 2^4 * 3^2 would become
         6 = 2 * 3.
  :      Divide the value by its deduplicated version, which decrements the
         exponents of its prime factors.
  .t     Duplicate the result and decrement it. This value becomes 0 once we
         reach a result of 1, which is when we want to terminate the loop.
$K     Jump back to the beginning of the loop if the previous value wasn't 0.
q      Retrieve the tape head's position, i.e. the number of steps we've taken
       through the above loop.

— Martin Ender
fonte

1

Julia, 60 52 40 byte

f(x)=maximum(collect(values(factor(x))))

-12 + correzione grazie a Steadybox

— EricShermanCS
fonte

1

Penso che devi aggiungere una chiamata a print(). Inoltre, non sono riuscito a far funzionare il codice su TIO così com'è, suppongo che funzioni su qualche altra versione della lingua non disponibile lì? Funziona bene su TIO: print(maximum(collect(values(factor(parse(BigInt,readline()))))))

— Steadybox il

Funziona sull'interprete (almeno sul mio computer). Inoltre provoca un avviso perché l'inizializzazione di un BigInt come quello è stata deprecata. Tuttavia, se copi e incolli il codice così com'è in un interprete Julia, dovrebbe funzionare. (se è richiesta una stampa perché deve essere esplicitamente stampata, la inserisco male)

— EricShermanCS

1

Il print()è necessario perché la risposta deve essere un programma completo (che visualizza l'output) o una funzione (che restituisce l'output). Altrimenti la tua soluzione va bene. Sembra che puoi salvare alcuni byte (ed evitare la stampa) in questo modo:f(x)=maximum(collect(values(factor(x))))

— Steadybox

1

Prego! Ecco un meta post su quale sia il formato consentito per una soluzione.

— Steadybox,

0

In realtà , 4 byte

w♂NM

Provalo online!

w♂NM - Programma completo.

w - Spinge la scomposizione in fattori primi come coppie [primo, esponente].
 ♂N - Ottieni l'ultimo elemento di ciascuno (gli esponenti).
   M - Massimo.

— Mr. Xcoder
fonte

Ho usato questa soluzione esatta per scrivere i casi di test :)

— Mego

@Mego Pensi che possa essere più breve (non voglio che tu vizia se ne hai uno più corto, solo chiedendo)? :)

— Mr. Xcoder,

No, credo che questo sia ottimale per In realtà.

— Mego

0

Python 2 , 64 byte

-4 byte grazie a H.PWiz.

lambda n:max(a*(n%k**a<1)for a in range(n)for k in range(2,-~n))

Provalo online!

La risposta di Haskell al porto di H.PWiz . Lo condivido solo perché sono orgoglioso di essere stato in grado di comprendere questo pezzo di codice Haskell e tradurlo. : P

— totallyhuman
fonte

Non range(1,n)funziona?

— H.Piz,

range(1, n)produce tutti i numeri interi in [1, n).

— totalmente umano il

1

Ah, beh, in realtà non è necessario andare fino in fondo pera

— H.Pwiz,

Oh, okay, non capisco completamente la matematica che sta dietro. : P Grazie!

— totalmente umano il

1

64 byte

— H.Piz,

0

Assioma, 61 byte

f n==(a:=factors n;reduce(max,[a.i.exponent for i in 1..#a]))

Questa è la prima volta che trovo che sia possibile definire la funzione senza l'uso della parentesi (). Invece di "f (n) ==" "fn ==" un carattere in meno ...

— RosLuP
fonte

0

Racchetta , 83 79 byte

(λ(n)(cadr(argmax cadr((let()(local-require math/number-theory)factorize)n))))

Provalo online!

(Non sono sicuro se esiste un consenso su ciò che costituisce una soluzione Racket completa, quindi vado con la convenzione Mathematica sul fatto che una funzione pura conta.)

Come funziona

factorizedà la fattorizzazione come un elenco di coppie: (factorize 108)dà '((2 2) (3 3)). Il secondo elemento di una coppia è dato da cadr, una scorciatoia per la composizione di car(testa di una lista) con cdr(coda di una lista).

Mi sento sciocco (cadr (argmax cadr list))a trovare il massimo dei secondi elementi, ma maxnon funziona sugli elenchi: (max (map cadr list))non fa quello che vogliamo. Non sono un esperto di racchetta, quindi forse c'è un modo standard migliore per farlo.

Racchetta, 93 byte

(λ(n)(define(p d m)(if(=(gcd m d)d)(+(p d(/ m d))1)0))(p(argmax(λ(d)(p d n))(range 2 n))n))

Provalo online!

Come funziona

Una versione alternativa che non importa factorizee fa invece tutto da zero, più o meno. La funzione (p m d)trova il più alto potere di dche divide me poi basta trovare il valore più alto di (p n d)per dtra il 2e n. (Non abbiamo bisogno di limitare questo ai numeri primi, poiché non ci sarà un potere composito che funzioni meglio dei poteri primi.)

— Misha Lavrov
fonte

Immagino che la maxsoluzione standard sia, (apply max (map cadr list)ma (cadr (argmax cadr list))sfortunatamente, è più breve.

— Misha Lavrov,

0

J, 9 byte

[:>./_&q:

Massimo di <./tutti gli esponenti principali_&q:

Provalo online!

— Giona
fonte

0

APL (NARS), 15 caratteri, 30 byte

{⌈/+/¨v∘=¨v←π⍵}

test:

  f←{⌈/+/¨v∘=¨v←π⍵}
  f¨2..12
1 1 2 1 1 1 3 2 1 1 2 
  f¨144 200 500 1024 3257832488
4 3 3 10 3

commento:

{⌈/+/¨v∘=¨v←π⍵}
          v←π⍵    π12 return 2 2 3; assign to v the array of prime divisors of argument ⍵
      v∘=¨        for each element of v, build one binary array, show with 1 where are in v array, else puts 0 
                  return one big array I call B, where each element is the binary array above
   +/¨            sum each binary element array of  B
 ⌈/               get the max of all element of B (that should be the max exponet)

— RosLuP
fonte

Esponenti Prime più grandi

Esempio

Casi test

05AB1E , 2 byte

Python 2 , 62 57 56 byte

Gelatina , 3 byte

Haskell , 61 60 50 48 46 byte

45 byte con un'importazione:

Ohm v2 , 2 byte

Spiegazione?

Python 2 , 78 byte

Japt -h , 9 7 byte

Mathematica, 27 byte

MATL , 4 byte

Brachylog , 5 byte

Spiegazione

Buccia , 5 byte

APL (Dyalog) , 19 byte

Javascript 54 byte

PARI / GP, 24 byte

Ottava , 25 byte

Spiegazione

Pyth , 7 byte

Python 2 , 90 84 byte

Gaia , 4 byte

Gaia , 4 byte

MY , 4 byte

Spiegazione?

Ottava : 30 byte

Provalo online!

Alice , 17 byte

Spiegazione

Julia, 60 52 40 byte

In realtà , 4 byte

Python 2 , 64 byte

Assioma, 61 byte

Racchetta , 83 79 byte

Come funziona

Racchetta, 93 byte

Come funziona

J, 9 byte

APL (NARS), 15 caratteri, 30 byte

Japt `-h` , 9 7 byte