Bei einer gegebenen Ganzzahl n >= 2wird der größte Exponent in seiner Primfaktorisierung ausgegeben. Dies ist die OEIS-Sequenz A051903 .

Beispiel

Lassen n = 144. Seine Hauptfaktorisierung ist 2^4 * 3^2. Der größte Exponent ist 4.

Testfälle

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

Probieren Sie es online!

Wie?

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

Probieren Sie es online!

Gelee , 3 Bytes

ÆEṀ

Probieren Sie es online!

ÆEÆ - Vollständiges Programm / Monadic Link.

ÆE - Array von Exponenten der Primfaktorisierung.
  Ṁ - Maximum.

_{Dies funktioniert auch in M . Probieren Sie es online!}

Haskell , 61 60 50 48 46 Bytes

-2 Bytes dank xnor

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

Probieren Sie es online!

45 Bytes bei einem Import:

import NumberTheory
maximum.map snd.factorize

Probieren Sie es online!

Ohm v2 , 2 Bytes

n↑

Probieren Sie es online!

Erläuterung?

Nein.

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

Probieren Sie es online!

-5 danke an ovs .

Diese Antwort führt keine Prime Checks durch. Stattdessen wird die Tatsache ausgenutzt, dass der höchste Exponent eines Primfaktors bei jeder Faktorisierung einer Zahl größer oder gleich dem Exponenten eines anderen Faktors ist.

Japt -h , 9 7 Bytes

k ü mÊn

Versuch es

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@#]&

Probieren Sie es online!

MATL , 4 Bytes

YFX>

Probieren Sie es online!

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

Brachylog , 5 Bytes

ḋḅlᵐ⌉

Probieren Sie es online!

Erläuterung

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

Schale , 5 Bytes

▲mLgp

Probieren Sie es online!

• p - Erhält die Primfaktoren.
• g - Gruppiert benachbarte Werte.
• mL - Ermittelt die Länge jeder Gruppe.
• ▲ - Maximum.

APL (Dyalog) , 19 Bytes

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

Probieren Sie es online!

Wie?

2pco⎕ - 2D-Array von Primfaktoren und Exponenten

1↓ - die Faktoren fallen lassen

⌈/ - maximal

Javascript 54 Bytes

* Annahme eines unendlichen Stacks (wie bei Code-Golf-Herausforderungen)

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

Wenn ich den n->Teil nicht zähle , sind es 21 Bytes.

Oktave , 25 Bytes

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

Probieren Sie es online!

Erläuterung

factorErzeugt das Array von (möglicherweise wiederholten) Prim-Exponenten. Die zweite Ausgabe von modegibt an, wie oft der Modus (dh der am häufigsten wiederholte Eintrag) erscheint.

Pyth , 7 Bytes

eShMr8P

Probieren Sie es hier aus.

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

Probieren Sie es online!

Gaia , 4 Bytes

ḋ)⌠)

Probieren Sie es online!

• ḋ- Berechnet die Primfaktorisierung als [Primzahl, Exponent] Paar.

  • ⌠ - Map und sammle das Ergebnis mit dem Maximalwert.

  • ) - Letztes Element (Exponent).

  • ) - Letztes Element (maximaler Exponent)

Gaia , 4 Bytes

ḋ)¦⌉

Probieren Sie es online!

• ḋ- Berechnet die Primfaktorisierung als [Primzahl, Exponent] Paar.

  • )¦ - Map mit dem letzten Element (Exponent).

  • ⌉ - Erhält das maximale Element.

MEIN , 4 Bytes

ωĖ⍐←

Probieren Sie es online!

Erläuterung?

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

Oktave : 30 Bytes

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

1. a=factor(x)gibt einen Vektor zurück, der die Primfaktoren von enthält x. Dies ist ein Vektor, der in aufsteigender Reihenfolge sortiert ist, wobei die Multiplikation aller Zahlen in sich selbst factor(x)ergibt x, so dass jede Zahl im Vektor eine Primzahl ist.
2. histc(...,a)berechnet ein Histogramm für den Primfaktor-Vektor, wobei die Klassen die Primfaktoren sind. Das Histogramm zählt auf, wie oft wir jede Primzahl gesehen haben, wodurch sich der Exponent jeder Primzahl ergibt. Wir können hier ein bisschen schummeln, denn obwohl factor(x)doppelte Zahlen oder Klassen zurückgegeben werden, erfasst nur eine der Klassen, wie oft wir eine Primzahl sehen.
3. max(...) gibt somit den größten Exponenten zurück.

Probieren Sie es online!

Alice , 17 Bytes

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

Probieren Sie es online!

Erläuterung

/o
\i@/...

Dies ist nur ein Framework für einfache arithmetische Programme mit dezimaler E / A. Das ...ist das eigentliche Programm, das bereits die Eingabe auf dem Stapel hat und die Ausgabe oben auf dem Stapel belässt.

Alice hat tatsächlich eingebaute Funktionen, um die Primfaktorisierung einer ganzen Zahl zu erhalten (auch bei Paaren aus Primzahl und Exponentenzahl), aber die kürzeste, die ich mir ausgedacht habe, ist 10 Bytes länger als diese.

Stattdessen besteht die Idee darin, dass wir wiederholt eine Kopie jedes einzelnen Primfaktors aus der Eingabe abtrennen, bis wir 1 erreichen . Die Anzahl dieser Schritte entspricht dem größten Prim-Exponenten. Wir werden den Bandkopf als Zählervariable missbrauchen.

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 + Korrektur dank Steadybox

Eigentlich 4 Bytes

w♂NM

Probieren Sie es online!

w♂NM - Volles Programm.

w - Pusht die Primfaktorisierung als [Prim, Exponent] -Paar.
 ♂N - Holen Sie sich das letzte Element von jedem (die Exponenten).
   M - Maximum.

Python 2 , 64 Bytes

-4 Bytes dank H.PWiz.

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

Probieren Sie es online!

Port von H.PWiz's Haskell Antwort . Ich teile dies nur, weil ich stolz bin, diesen Teil des Haskell-Codes verstehen und übersetzen zu können. : P

Axiom 61 Bytes

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

Dies ist das erste Mal, dass ich finde, dass es möglich ist, die Funktion ohne die Verwendung von () Klammern zu definieren. Anstelle von "f (n) ==" "fn ==" ein Zeichen weniger ...

Schläger , 83 79 Bytes

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

Probieren Sie es online!

(Ich bin mir nicht sicher, ob es einen Konsens darüber gibt, was eine vollständige Racket-Lösung ausmacht. Deshalb gehe ich nach der Mathematica-Konvention vor, dass eine reine Funktion zählt.)

Wie es funktioniert

factorizeergibt die Faktorisierung als Liste von Paaren: (factorize 108)ergibt'((2 2) (3 3)) . Das zweite Element eines Paares ist gegeben durch cadr, eine Abkürzung für die Zusammensetzung von car(Kopf einer Liste) mit cdr(Ende einer Liste).

Ich fühle mich dumm dabei (cadr (argmax cadr list)) finde es , das Maximum der zweiten Elemente zu finden, maxarbeite aber nicht an Listen: (max (map cadr list))Tue nicht, was wir wollen. Ich bin kein Schlägerexperte. Vielleicht gibt es einen besseren Standard, um dies zu tun.

Schläger, 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))

Probieren Sie es online!

Wie es funktioniert

Eine alternative Version, die nicht importiert factorizeund stattdessen mehr oder weniger alles von Grund auf neu erstellt. Die Funktion (p m d)findet die höchste Potenz ddieser Division mund dann finden wir einfach den höchsten Wert (p n d)für dzwischen 2und n. (Wir müssen dies nicht auf Primzahlen beschränken, da es keine zusammengesetzte Kraft geben wird, die besser funktioniert als Primzahlen.)

J 9 Bytes

[:>./_&q:

Max <./aller Hauptexponenten_&q:

Probieren Sie es online!

APL (NARS), 15 Zeichen, 30 Byte

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

Prüfung:

  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 

Kommentar:

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