รับจำนวนเต็มn >= 2ส่งออกเลขชี้กำลังที่ใหญ่ที่สุดในการแยกตัวประกอบเฉพาะ นี่คือ OEIS ลำดับA051903

ตัวอย่าง

n = 144ให้ 2^4 * 3^2ตัวประกอบที่สำคัญของมันคือ 4ตัวแทนที่ใหญ่ที่สุดคือ

กรณีทดสอบ

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 ไบต์

ÓZ

ลองออนไลน์!

อย่างไร?

Ó   exponents of prime factors
 Z  maximum

Python 2 , 62 57 56 ไบต์

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

ลองออนไลน์!

เยลลี่ 3 ไบต์

ÆEṀ

ลองออนไลน์!

ÆEṀ - ลิงก์โปรแกรมเต็ม / Monadic

ÆE - อาร์เรย์ของเลขชี้กำลังของการแยกตัวประกอบเฉพาะ
  Ṁ - สูงสุด

_{นอกจากนี้ยังทำงานในM ลองออนไลน์!}

Haskell , 61 60 50 48 46 ไบต์

-2 ไบต์ขอบคุณxnor

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

ลองออนไลน์!

45 ไบต์พร้อมการนำเข้า:

import NumberTheory
maximum.map snd.factorize

ลองออนไลน์!

โอห์ม v2 , 2 ไบต์

n↑

ลองออนไลน์!

คำอธิบาย?

เลขที่

Python 2 , 78 ไบต์

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

ลองออนไลน์!

-5 ขอบคุณที่OVS

คำตอบนี้ไม่ทำการตรวจสอบเฉพาะ แต่จะใช้ประโยชน์จากความจริงที่ว่าเลขชี้กำลังสูงสุดของปัจจัยหลักจะมากกว่าหรือเท่ากับเลขชี้กำลังของปัจจัยอื่นใดในการแยกตัวประกอบของจำนวนใด ๆ

Japt -h , 9 7 ไบต์

k ü mÊn

ลองมัน

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 ไบต์

Max[Last/@FactorInteger@#]&

ลองออนไลน์!

MATL , 4 ไบต์

YFX>

ลองออนไลน์!

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

Brachylogขนาด 5 ไบต์

ḋḅlᵐ⌉

ลองออนไลน์!

คำอธิบาย

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

Husk , 5 ไบต์

▲mLgp

ลองออนไลน์!

• p - รับปัจจัยสำคัญ
• g - จัดกลุ่มค่าที่อยู่ติดกัน
• mL - รับความยาวของแต่ละกลุ่ม
• ▲ - สูงสุด

APL (Dyalog)ขนาด 19 ไบต์

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

ลองออนไลน์!

อย่างไร?

2pco⎕ - อาร์เรย์ 2 มิติของปัจจัยสำคัญและเลขชี้กำลัง

1↓ - วางปัจจัย

⌈/ - สูงสุด

Javascript 54 ไบต์

* สมมติว่าเป็นอนันต์สแต็ก (เช่นเดียวกับการท้าทายของ 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)

PARI / GP ขนาด 24 ไบต์

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

หากฉันไม่นับn->ส่วนหนึ่งก็คือ 21 ไบต์

อ็อกเทฟ 25 ไบต์

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

ลองออนไลน์!

คำอธิบาย

factorสร้างอาร์เรย์ของเอกซ์โพเนนเชียล Prime (อาจซ้ำกัน) เอาต์พุตที่สองของmodeจำนวนครั้งที่โหมด (เช่นรายการที่ซ้ำกันมากที่สุด) ปรากฏขึ้น

Pyth , 7 ไบต์

eShMr8P

ลองที่นี่

Python 2 , 90 84 ไบต์

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

ลองออนไลน์!

Gaiaขนาด 4 ไบต์

ḋ)⌠)

ลองออนไลน์!

• ḋ- คำนวณตัวประกอบที่สำคัญเป็น[นายกตัวแทน]คู่

  • ⌠ - แมปและรวบรวมผลลัพธ์ด้วยค่าสูงสุด

  • ) - องค์ประกอบสุดท้าย (เลขยกกำลัง)

  • ) - องค์ประกอบสุดท้าย (เลขยกกำลังสูงสุด)

Gaiaขนาด 4 ไบต์

ḋ)¦⌉

ลองออนไลน์!

• ḋ- คำนวณตัวประกอบที่สำคัญเป็น[นายกตัวแทน]คู่

  • )¦ - แผนที่ที่มีองค์ประกอบสุดท้าย (เลขยกกำลัง)

  • ⌉ - รับค่าอิลิเมนต์สูงสุด

MY , 4 ไบต์

ωĖ⍐←

ลองออนไลน์!

คำอธิบาย?

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

ระดับเสียง : 30 ไบต์

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

1. a=factor(x)xผลตอบแทนที่ได้เวกเตอร์ที่มีปัจจัยที่สำคัญของ นี่คือเวกเตอร์เรียงตามลำดับจากน้อยไปมากที่การคูณของตัวเลขทั้งหมดfactor(x)ทำให้ได้ผลxนั้นเองซึ่งตัวเลขแต่ละตัวในเวกเตอร์นั้นเป็นจำนวนเฉพาะ
2. histc(...,a)คำนวณฮิสโตแกรมบนเวกเตอร์ปัจจัยเฉพาะซึ่งถังขยะเป็นปัจจัยสำคัญ ฮิสโตแกรมนับจำนวนครั้งที่เราเห็นแต่ละหมายเลขเฉพาะจึงให้เลขชี้กำลังของจำนวนเฉพาะ เราสามารถโกงที่นี่เล็กน้อยเพราะแม้ว่าfactor(x)จะส่งคืนหมายเลขหรือถังขยะซ้ำกัน แต่มีเพียงหนึ่งในถังขยะเท่านั้นที่จะจับภาพจำนวนครั้งทั้งหมดที่เราเห็นจำนวนเฉพาะ
3. max(...) ดังนั้นส่งคืนเลขชี้กำลังใหญ่ที่สุด

ลองออนไลน์!

อลิซ 17 ไบต์

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

ลองออนไลน์!

คำอธิบาย

/o
\i@/...

นี่เป็นเพียงกรอบสำหรับโปรแกรมทางคณิตศาสตร์อย่างง่ายที่มีทศนิยม I / O ...เป็นโปรแกรมที่เกิดขึ้นจริงที่แล้วมีการป้อนข้อมูลในกองใบไม้และการส่งออกที่ด้านบนของสแต็ค

จริงๆแล้วอลิซมีโครงสร้างภายในเพื่อให้ได้ตัวประกอบจำนวนเต็ม (แม้จะมีคู่ไพร์ม - เอกซ์โพเนนต์) แต่ที่สั้นที่สุดที่ฉันใช้กับมันคือ 10 ไบต์ที่ยาวกว่านี้

แต่ความคิดที่ว่าเราซ้ำ ๆ แบ่งหนึ่งสำเนาของแต่ละปัจจัยสำคัญที่แตกต่างจากการป้อนข้อมูลจนกว่าจะถึง1 จำนวนขั้นตอนนี้ใช้เท่ากับเลขชี้กำลังที่ใหญ่ที่สุด เราจะใช้หัวเทปในฐานะตัวแปรตัวนับ

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 ไบต์

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

-12 + การแก้ไขด้วยSteadybox

จริงแล้ว 4 ไบต์

w♂NM

ลองออนไลน์!

w♂NM - โปรแกรมเต็มรูปแบบ

w - เพิ่มการแยกตัวประกอบเฉพาะเป็นคู่ [ไพร์ม, เลขชี้กำลัง]
 ♂N - รับองค์ประกอบสุดท้ายของแต่ละ (เลขชี้กำลัง)
   M - สูงสุด

Python 2 , 64 ไบต์

-4 ไบต์ขอบคุณ H.PWiz

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

ลองออนไลน์!

ท่าเรือH.PWiz เป็นคำตอบ ฉันแบ่งปันสิ่งนี้เพียงเพราะฉันภูมิใจที่ฉันสามารถเข้าใจรหัส Haskell ชิ้นนี้และแปลได้ : P

ความจริง 61 ไบต์

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

นี่เป็นครั้งแรกที่ฉันพบว่าเป็นไปได้ที่จะกำหนดฟังก์ชั่นโดยไม่ต้องใช้วงเล็บ () แทนที่จะเป็น "f (n) ==" "fn ==" หนึ่งตัวอักษรน้อยกว่า ...

แร็กเก็ต , 83 79 ไบต์

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

ลองออนไลน์!

(ฉันไม่แน่ใจว่ามีฉันทามติเกี่ยวกับสิ่งที่ถือเป็นการแก้ปัญหาแร็กเกตที่สมบูรณ์ดังนั้นฉันจะไปกับการประชุม Mathematica ที่ฟังก์ชั่นบริสุทธิ์นับ

มันทำงานอย่างไร

factorizeให้ตีนเป็ดเป็นรายการของคู่: ให้(factorize 108) '((2 2) (3 3))องค์ประกอบที่สองของคู่จะได้รับโดยcadrย่อสำหรับองค์ประกอบของcar(หัวของรายการ) กับcdr(ส่วนท้ายของรายการ)

ฉันรู้สึกโง่ที่ทำ(cadr (argmax cadr list))เพื่อค้นหาองค์ประกอบสูงสุดที่สอง แต่maxไม่ทำงานในรายการ: (max (map cadr list))ไม่ทำสิ่งที่เราต้องการ ฉันไม่ใช่ผู้เชี่ยวชาญใน Racket ดังนั้นอาจมีวิธีที่ดีกว่าในการทำเช่นนี้

แร็กเก็ต, 93 ไบต์

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

ลองออนไลน์!

มันทำงานอย่างไร

รุ่นอื่นที่ไม่นำเข้าfactorizeและจะทำทุกอย่างตั้งแต่เริ่มต้นไม่มากก็น้อย ฟังก์ชั่น(p m d)พบว่าอำนาจสูงสุดของการdแบ่งว่าmแล้วเราก็หาค่าสูงสุดของ(p n d)สำหรับdระหว่างและ2 n(เราไม่จำเป็นต้อง จำกัด สิ่งนี้เฉพาะช่วงเวลาเนื่องจากไม่มีพลังประกอบที่ทำงานได้ดีกว่าพลังพิเศษ)

J, 9 ไบต์

[:>./_&q:

จำนวนสูงสุดของ<./เลขยกกำลังทั้งหมด_&q:

ลองออนไลน์!

APL (NARS), 15 ตัวอักษร, 30 ไบต์

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

ทดสอบ:

  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 

แสดงความคิดเห็น:

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