Dado un número entero n >= 2, genera el mayor exponente en su factorización prima. Esta es la secuencia OEIS A051903 .

Ejemplo

Dejar n = 144. Su factorización principal es 2^4 * 3^2. El mayor exponente es 4.

Casos de prueba

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

05AB1E , 2 bytes

ÓZ

Pruébalo en línea!

¿Cómo?

Ó   exponents of prime factors
 Z  maximum

Python 2 , 62 57 56 bytes

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

Pruébalo en línea!

Jalea , 3 bytes

ÆEṀ

Pruébalo en línea!

ÆEṀ - Programa completo / Enlace monádico.

ÆE - Matriz de exponentes de factorización prima.
  Ṁ - Máximo.

_{Esto también funciona en M . Pruébalo en línea!}

Haskell , 61 60 50 48 46 bytes

-2 bytes gracias a xnor

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

Pruébalo en línea!

45 bytes con una importación:

import NumberTheory
maximum.map snd.factorize

Pruébalo en línea!

Ohm v2 , 2 bytes

n↑

Pruébalo en línea!

¿Explicación?

No.

Python 2 , 78 bytes

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

Pruébalo en línea!

-5 gracias a los ovs .

Esta respuesta no hace verificaciones principales. En cambio, aprovecha el hecho de que el máximo exponente de un factor primo será mayor o igual que el exponente de cualquier otro factor en cualquier factorización de un número.

Japt -h , 9 7 bytes

k ü mÊn

Intentalo

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

Mathematica, 27 bytes

Max[Last/@FactorInteger@#]&

Pruébalo en línea!

MATL , 4 bytes

YFX>

Pruébalo en línea!

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

Brachylog , 5 bytes

ḋḅlᵐ⌉

Pruébalo en línea!

Explicación

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

Casco , 5 bytes

▲mLgp

Pruébalo en línea!

• p - Obtiene los factores primos.
• g - Agrupa valores adyacentes.
• mL - Obtiene las longitudes de cada grupo.
• ▲ - Máximo.

APL (Dyalog) , 19 bytes

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

Pruébalo en línea!

¿Cómo?

2pco⎕ - Matriz 2D de factores primos y exponentes

1↓ - descartar los factores

⌈/ - máximo

Javascript 54 bytes

* suponiendo una pila infinita (como en los desafíos de código de 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)

PARI / GP, 24 bytes

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

Si no cuento la n->parte, son 21 bytes.

Octava , 25 bytes

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

Pruébalo en línea!

Explicación

factorproduce la matriz de exponentes primos (posiblemente repetidos) La segunda salida de modeda el número de veces que aparece el modo (es decir, la entrada más repetida).

Pyth , 7 bytes

eShMr8P

Pruébalo aquí

Python 2 , 90 84 bytes

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])

Pruébalo en línea!

Gaia , 4 bytes

ḋ)⌠)

Pruébalo en línea!

• ḋ- Calcula la factorización prima como pares [primo, exponente] .

  • ⌠ - Mapa y recoger el resultado con el valor máximo.

  • ) - Último elemento (exponente).

  • ) - Último elemento (exponente máximo)

Gaia , 4 bytes

ḋ)¦⌉

Pruébalo en línea!

• ḋ- Calcula la factorización prima como pares [primo, exponente] .

  • )¦ - Mapa con el último elemento (exponente).

  • ⌉ - Obtiene el elemento máximo.

MY , 4 bytes

ωĖ⍐←

Pruébalo en línea!

¿Explicación?

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

Octava : 30 bytes

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

1. a=factor(x)devuelve un vector que contiene los factores primos de x. Este es un vector ordenado en orden ascendente en el que la multiplicación de todos los números en sí factor(x)produce xtal que cada número en el vector es primo.
2. histc(...,a)calcula un histograma en el vector de factores primos donde los contenedores son los factores primos. El histograma cuenta cuántas veces hemos visto cada número primo, dando así el exponente de cada número primo. Podemos hacer trampa aquí un poco porque, aunque factor(x)devolverá números o bins duplicados, solo uno de los bins capturará la cantidad total de veces que vemos un número primo.
3. max(...) devuelve así el mayor exponente.

Pruébalo en línea!

Alice , 17 bytes

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

Pruébalo en línea!

Explicación

/o
\i@/...

Esto es solo un marco para programas aritméticos simples con E / S decimal. El ...es el programa real, que ya tiene la entrada en la pila y deja la salida en la parte superior de la pila.

Alice en realidad tiene incorporados para obtener la factorización prima de un número entero (incluso con pares primos-exponentes), pero el más corto que he encontrado usando esos es 10 bytes más largo que esto.

En cambio, la idea es que dividimos repetidamente una copia de cada factor primo distinto de la entrada, hasta llegar a 1 . El número de pasos que esto toma es igual al mayor exponente principal. Abusaremos del cabezal de la cinta como la variable del contador.

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.

Julia, 60 52 40 bytes

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

-12 + corrección gracias a Steadybox

En realidad , 4 bytes

w♂NM

Pruébalo en línea!

w♂NM - Programa completo.

w - Empuja la factorización prima como pares [primo, exponente].
 ♂N - Obtiene el último elemento de cada uno (los exponentes).
   M - Máximo.

Python 2 , 64 bytes

-4 bytes gracias a H.PWiz.

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

Pruébalo en línea!

Respuesta de Haskell del puerto de H.PWiz . Solo comparto esto porque estoy orgulloso de haber podido entender este fragmento de código Haskell y traducirlo. :PAGS

Axioma, 61 bytes

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

Esta es la primera vez que encuentro que es posible definir la función sin el uso del paréntesis (). En lugar de "f (n) ==" "fn ==" un carácter menos ...

Raqueta , 83 79 bytes

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

Pruébalo en línea!

(No estoy seguro de si hay un consenso sobre lo que constituye una solución Racket completa, así que voy con la convención de Mathematica de que una función pura cuenta).

Cómo funciona

factorizeda la factorización como una lista de pares: (factorize 108)da '((2 2) (3 3)). El segundo elemento de un par viene dado por cadr, una abreviatura para la composición de car(encabezado de una lista) con cdr(cola de una lista).

Me siento tonto (cadr (argmax cadr list))por encontrar el máximo de los segundos elementos, pero maxno funciona en las listas: (max (map cadr list))no hace lo que queremos. No soy un experto en Racket, así que quizás haya una mejor manera estándar de hacer esto.

Raqueta, 93 bytes

(λ(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))

Pruébalo en línea!

Cómo funciona

Una versión alternativa que no importa factorizey en su lugar hace todo desde cero, más o menos. La función (p m d)encuentra el poder más alto de desa división my luego solo encontramos el valor más alto de (p n d)para dentre 2y n. (No necesitamos restringir esto a números primos, ya que no habrá un poder compuesto que funcione mejor que los poderes primarios).

J, 9 bytes

[:>./_&q:

Máx. De <./todos los exponentes primos_&q:

Pruébalo en línea!

APL (NARS), 15 caracteres, 30 bytes

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

prueba:

  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 

comentario:

{⌈/+/¨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)