พลังงานหลักคือจำนวนเต็มบวกnที่สามารถเขียนได้ในรูปแบบn = p ^kโดยที่pคือจำนวนเฉพาะและkเป็นจำนวนเต็มบวก [2, 3, 5, 4, 9, 25, 8, 27, 125]ตัวอย่างเช่นบางอำนาจที่สำคัญมี

ถัดไปพิจารณาอำนาจที่สำคัญของ 2 เหล่านี้จะ[2, 4, 8, 16, ...]สามารถนำมาเขียนในรูปแบบที่ 2 k พวกเขาทั้งหมดจะถูกรวมเข้าด้วยกันเมื่อพิจารณามหาอำนาจที่ต่ำกว่า 20 อย่างไรก็ตาม 16 เป็นพลังที่สำคัญสูงสุดโดยมีค่าฐานสูงสุดเป็น 2 ในช่วงนั้น พลังพิเศษp ^kคือสูงสุดในช่วงถ้ามันเป็นพลังสูงสุดของpในช่วงนั้น เราสนใจเฉพาะพลังงานที่สำคัญสูงสุดในแต่ละช่วงเท่านั้นดังนั้นจึงไม่รวมพลังที่สำคัญทั้งหมด

เป้าหมายของคุณคือการเขียนฟังก์ชั่นหรือโปรแกรมที่ใช้เป็นจำนวนเต็มบวกnและออกผลลัพธ์เป็นสูงสุด[2, 3, 4, ..., n]พลังสำคัญในช่วง

ขอขอบคุณ @ Peter Taylor ที่ให้คำจำกัดความของอำนาจสูงสุดสูงสุดและอื่น ๆ

กฎระเบียบ

• นี่คือรหัสกอล์ฟเพื่อให้รหัสของคุณสั้นที่สุด
• สูงสุดพลังที่สำคัญอาจจะมีการส่งออกในลำดับใด ๆ แต่จะต้องไม่มีซ้ำกัน

กรณีทดสอบ

n      result
1      []
2      [2]
3      [2, 3]
4      [3, 4]
5      [3, 4, 5]
6      [3, 4, 5]
7      [3, 4, 5, 7]
20     [5, 7, 9, 11, 13, 16, 17, 19]
50     [11, 13, 17, 19, 23, 25, 27, 29, 31, 32, 37, 41, 43, 47, 49]
100    [11, 13, 17, 19, 23, 25, 29, 31, 37, 41, 43, 47, 49, 53, 59, 61, 64, 67, 71, 73, 79, 81, 83, 89, 97]
10000  <1229 results>
       [101, 103, 107, 109, 113, 127, 131, 137, 139, 149, ..., 9887, 9901, 9907, 9923, 9929, 9931, 9941, 9949, 9967, 9973]

รายการเต็มรูปแบบของอำนาจที่สำคัญสูงสุดสำหรับ 10000 สามารถพบได้ที่นี่

เยลลี่ , 7 4 ไบต์

æḟÆR

ลองออนไลน์!

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

æḟÆR  Main link. Argument: n

  ÆR  Prime range; yield all primes in [1, ..., n].
æḟ    Power floor; round n down to the nearest power of each prime in the range.

Mathematica, 44 43 40 ไบต์

บันทึกแล้ว 4 ไบต์ด้วยไมล์และ Martin Ender

n#^⌊#~Log~n⌋&/@Select[Range@n,PrimeQ]

(x=Prime@Range@PrimePi@#)^⌊x~Log~#⌋&

⌊และ⌋เป็น3อักขระไบต์U+230AและU+230Bเป็นตัวแทน\[LeftFloor]และ\[RightFloor]ตามลำดับ

คำอธิบาย:

ฟังก์ชั่นบริสุทธิ์ #สั้นสำหรับซึ่งหมายถึงอาร์กิวเมนต์แรกไปSlot[1] นับจำนวน primes น้อยกว่าหรือเท่ากับ, คือรายการแรกจำนวนเต็มบวกและเพื่อให้เป็นรายการของจำนวนเฉพาะที่น้อยกว่าหรือเท่ากับ(นี้เป็นหนึ่งไบต์สั้นกว่า) สัญลักษณ์คือเท่ากับรายการนี้แล้วยกซึ่งเป็นรายการของแต่ละใน ใน Mathematica การเพิ่มรายการไปยังรายการความยาวเดียวกันอีกรายการหนึ่งส่งผลให้รายการของพลังขององค์ประกอบที่สอดคล้องกันFunctionPrimePi@##Range@PrimePi@#PrimePi[#]Prime@Range@PrimePi@##Select[Range@#,PrimeQ]xSetPower ⌊x~Log~#⌋Floor[Log[n,#]]nxPower

MATL, 13 ไบต์

ZqG:!^tG>~*X>

ลองออนไลน์!

คำอธิบาย

        % Implicitly grab the input as a number (N)
Zq      % Get an array of all primes below N
G:!     % Create an array from [1...N]
^       % Raise each prime to each power in this array which creates a 2D matrix
        % where the powers of each prime are down the columns
tG>~    % Create a logical matrix that is TRUE where the values are less than N
*       % Perform element-wise multiplication to force values > N to zero
X>      % Compute the maximum value of each column
        % Implicitly display the resulting array

เยลลี่ขนาด 8 ไบต์

ÆR*ÆE€»/

ลองออนไลน์!

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

ÆR*ÆE€»/  Main link. Argument: n

ÆR        Prime range; yield all primes in [1, ..., n].
   ÆE€    Prime exponents each; yield the exponents of 2, 3, 5, ... of the prime
          factorization of each k in [1, ..., n].
          For example, 28 = 2² × 3⁰ × 5⁰ × 7¹ yields [2, 0, 0, 1].
  *       Exponentiation; raise the elements of the prime range to the powers
          of each of the exponents arrays.
      »/  Reduce the columns by maximum.

เจลลี่ , 12 9 ไบต์

RÆEz0iṀ$€

ลองออนไลน์! (วิธีการช้าเกินไปสำหรับกรณี 10,000)

อย่างไร?

สร้างรายชื่อของพี^kในคำสั่งของพี

RÆEz0iṀ$€ - Main link: n                      e.g. 7
R         - range(n)                          [1 ,2  ,3    ,4  ,5      ,6    ,7]
 ÆE       - prime factor vector (vectorises)  [[],[1],[0,1],[2],[0,0,1],[1,1],[0,0,0,1]]
   z0     - transpose with filler 0           [[0,1,0,2,0,1,0],[0,0,1,0,0,1,0],[0,0,0,0,1,0,0],[0,0,0,0,0,0,1]]
       $€ - la$t two links as a monad, for €ach       ^             ^                   ^                   ^
     i    -     first index of                        4             3                   5                   7
      Ṁ   -     maximum                       [4,3,5,7]

Pyth, 13 ไบต์

m^ds.lQdfP_TS

ลองที่นี่!

        f   S -  filter(v, range(1, input))
         P_T  -   is_prime(T)
m             - map(v, ^)
    .lQd      -    log(input, d)
   s          -   int(^)
 ^d           -  d ** ^

ฉันไม่ได้เล่นกับ Pyth ในขณะที่คำแนะนำการเล่นกอล์ฟใด ๆ ที่ชื่นชม

ฉันไม่สามารถรับ Mathematica ที่สั้นกว่าสารละลายของ ngenisis ได้แต่ฉันคิดว่าฉันเสนอวิธีการทางเลือกอื่น ๆ

Mathematica, 65 ไบต์

#/#2&@@@({#,#}&/@Range@#~Select~PrimeQ//.{a_,b_}/;a<=#:>{b a,b})&

ครั้งแรกที่เราใช้{#,#}&/@Range@#~Select~PrimeQในการสร้างรายชื่อของช่วงเวลาทั้งหมดอยู่ในช่วงที่เหมาะสม { {2,2}, {3,3}, ...}แต่มีคู่ได้รับคำสั่งของแต่ละที่สำคัญเช่น จากนั้นเราดำเนินการในรายการนั้นซ้ำ ๆ กับกฎการแทนที่{a_,b_}/;a<=#:>{b a,b}ซึ่งจะเพิ่มองค์ประกอบแรกของคู่ที่สั่งเป็นสองเท่าจนกระทั่งองค์ประกอบแรกเกินกว่าอินพุต จากนั้นเรานำ#/#2&@@@ไปใช้กับผลลัพธ์สำหรับคู่ที่สั่งซื้อแต่ละองค์ประกอบแรกจะถูกหารด้วยจำนวนที่สอง (ท้ายที่สุดจะเรียงลำดับตามไพร์มพื้นฐาน: เอาต์พุตตัวอย่างคือ{16, 9, 5, 7, 11, 13, 17, 19})

Mathematica ขนาด 44 ไบต์

Values@Rest@<|MangoldtLambda@#->#&~Array~#|>&

ฟังก์ชัน von Mangoldt Λ(n)เป็นฟังก์ชันทฤษฎีจำนวนที่น่าสนใจ: มันเท่ากับ 0 เว้นแต่ว่าnเป็นพลังอันดับต้น p ^kซึ่งในกรณีนี้มันจะเท่ากับlog p(ไม่log n) (นี่คือบันทึกธรรมชาติ แต่จะไม่สำคัญ) ดังนั้นจึงMangoldtLambda@#->#&~Array~#สร้างกฎ{ 0->1, Log[2]->2, Log[3]->3, Log[2]->4, Log[5]->5, 0->6, ... }ที่มีความยาวเป็นจำนวนเต็มเข้า

จากนั้นเราจะเปิดรายการของกฎนี้เป็น "สมาคม" <|...|>โดยใช้ สิ่งนี้มีผลในการรักษากฎล่าสุดที่มีค่าทางซ้ายมือที่กำหนดไว้เท่านั้น ในคำอื่น ๆ ก็จะโยนออกไปLog[2]->2และLog[2]->4และLog[2]->8และเก็บเฉพาะLog[2]->16(สมมติว่าใส่เป็นระหว่างวันที่ 16 และ 31 สำหรับตัวอย่างนี้) ดังนั้นทางด้านขวามือเดียวที่เหลืออยู่คือมหาอำนาจสูงสุดสูงสุด - ยกเว้นกฎที่เหลือเพียงอันเดียว0->nซึ่งnเป็นพลังงานที่ไม่ใหญ่ที่สุดจนถึงจำนวนเต็มอินพุต แต่Restโยนกฎที่ไม่พึงประสงค์ออกไปและValuesดึงด้านขวาออกจากกฎในสมาคม (ท้ายที่สุดเรียงลำดับไว้ด้านบน)

เวอร์ชันที่ยาวกว่า (46 ไบต์) เล็กน้อยซึ่งนับจำนวนการปรากฏของแต่ละอันlog pแล้ว exponentiates เพื่อแปลงเป็นมหาอำนาจสูงสุด:

E^(1##)&@@@Rest@Tally[MangoldtLambda~Array~#]&

CJam , 21 20 ไบต์

บันทึก 1 ไบต์ขอบคุณ Martin Ender

ri_){mp},f{\1$mLi#}p

ลองออนไลน์!

คำอธิบาย

ri                    e# Read an integer from input (let's call it n)
  _                   e# Duplicate it
   ){mp},             e# Push the array of all prime numbers up to and including n
         f{           e# Map the following block to each prime p:
           \          e#   Swap the top two elements of the stack
            1$        e#   Copy the second element down in the stack. Stack is now [p n p]
              mL      e#   Take the base-p logatithm of n
                i     e#   Cast to int (floor)
                 #    e#   Raise p to that power
                  }   e# (end of map block)
                   p  e# Print

Brachylogขนาด 15 ไบต์

⟧{ḋ=}ˢ⊇Xhᵐ≠∧X×ᵐ

ลองออนไลน์!

สิ่งนี้ให้พลังจากมากไปหาน้อย

มันไม่มีประสิทธิภาพมาก

คำอธิบาย

⟧                   The Range [Input, Input - 1, ..., 1, 0]
 {  }ˢ              Select:
  ḋ=                  The elements of that range whose prime decompositions are lists of the
                      same element (e.g. [3,3,3]); output is those prime decompositions
      ⊇X            X is an ordered subset of that list of prime decompositions
       Xhᵐ≠         All first elements of the prime decompositions are different (that is,
                      X contains prime decompositions with different primes each times)
           ∧
            X×ᵐ     Output is the result of mapping multiplication to each element of X

สิ่งนี้จะค้นหาการแยกย่อยที่สำคัญที่สุดสำหรับแต่ละไพร์มก่อนเนื่องจากวิธีการ⊇ทำงาน: จากซ้ายไปขวาและจากเซ็ตย่อยที่ใหญ่ที่สุดไปหาน้อยที่สุด

Brachylog , 24 21 19 ไบต์

บันทึกขนาด 3 + 2 ไบต์ด้วย Fatalize!

นี่เป็นครั้งแรกที่ฉันได้ใช้งาน Brachylog และฉันรู้ว่าบางสิ่งสามารถทำได้ด้วยวิธีที่สั้นกว่านี้ แต่ฉันดีใจที่มันใช้งานได้: D

{≥.~^ℕ₁ᵐhṗ:.≜×>?∧}ᶠ

ลองออนไลน์! (ค่าส่งคืนถูกจัดเรียงตามช่วงเวลาพื้นฐาน)

คำอธิบาย:

{................}ᶠ           #Find all possible results of what's inside.
 ≥.                           #Input is >= than the output.
  .~^ℕ₁ᵐ                      #Output can be calculated as A^B, where A and B are
                              #Natural numbers >=1.
        hṗ                    #The first of those numbers (A) is prime
          :.≜×>?              #That same element (A), multiplied by the output
                              #is greater than the input - This means 
                              #that B is the maximal exponent for A.
                ∧             #No more restrictions on the output.

05AB1E , 15 12 ไบต์

ƒNpiN¹N.nïm,

ลองออนไลน์!

คำอธิบาย

ƒ             # for N in [0 ... input]
 Npi          # if N is prime
    N         # push N
     ¹N.n     # push log_N(input)
         ï    # convert to int
          m   # raise N to this power
           ,  # print

ยูทิลิตีBash + GNU ขนาด 74 ไบต์

seq $1|factor|sed "s@.*: \(\w*\)\$@\1;l($1);l(\1);print \"/^p\"@"|bc -l|dc

ลองออนไลน์!

หมายเลขอินพุตถูกส่งผ่านเป็นอาร์กิวเมนต์ เอาต์พุตถูกพิมพ์ไปที่ stdout (ตามธรรมเนียม stderr ถูกละเว้น)

ตัวอย่างผลลัพธ์:

./maximalprimepowers 100 2>/dev/null
64
81
25
49
11
13
17
19
23
29
31
37
41
43
47
53
59
61
67
71
73
79
83
89
97

./maximalprimepowers 10000 2>/dev/null | wc -l
1229

นี่คือวิธีการทำงาน:

เรียกอาร์กิวเมนต์ N

seq สร้างตัวเลขทั้งหมดตั้งแต่ 1 ถึง N และ factorปัจจัยเหล่านั้นทั้งหมด

regex ในการเรียกเพื่อ sed ระบุบรรทัดเหล่านั้นโดยที่ number นั้นเป็นไพรม์ P และแทนที่บรรทัดเหล่านั้นด้วยบรรทัดที่อยู่ในรูปแบบ `

P;l(N);l(P);print "/^p"

(โดยที่ P และ N จะถูกแทนที่ด้วยค่าตัวเลขจริงของพวกเขาและทุกอย่างอื่นจะถูกคัดลอกอย่างแท้จริงแม้เครื่องหมายคำพูดและเครื่องหมายอัฒภาคและสตริง print )

เส้นเหล่านี้เป็นอาหารเป็น input เพื่อbc -l; bc พิมพ์ค่าของตัวเลขที่ระบุสามตัวแต่ละตัวตามด้วยการขึ้นบรรทัดใหม่แล้วพิมพ์อักขระ/^pพิมพ์ค่าในสามของจำนวนที่ระบุไว้ในแต่ละตามด้วยการขึ้นบรรทัดใหม่แล้วพิมพ์ตัวอักษร (ใน bc, l (x) หมายถึงลอการิทึมธรรมชาติของ x.) JK K

สตริงที่พิมพ์ bc นั้นจะถูกป้อนเข้าเป็น dc dc พิมพ์ค่าของแต่ละ P ^ (log (N) / log (P)) โดยใช้เลขคณิตเลขจำนวนเต็ม (ตัด) นั่นคือพลังที่ยิ่งใหญ่ที่สุดของ P นั่นคือ <= N

สิ่งหนึ่งที่คัดสรรมาแล้วข้างต้นคือสิ่งที่เกิดขึ้นกับเส้นที่เกิดจากปัจจัยที่ไม่สอดคล้องกับช่วงเวลา บรรทัดเหล่านั้นไม่ตรงกับ regex ในการเรียกไปยัง sed ดังนั้นจึงไม่มีการแทนที่บนบรรทัดเหล่านั้น เป็นผลให้เส้นที่เริ่มต้นด้วยตัวเลขตามด้วยเครื่องหมายซึ่งสร้างข้อผิดพลาดเมื่อเลี้ยงเป็น input bcเพื่อ แต่ bc เพียงพิมพ์ไปที่ stderr แล้วซึ่งเราไม่สนใจ มันไม่ได้พิมพ์อะไรเพื่อ stdout โดยค่าเริ่มต้นstderr ถูกละเว้นใน PPCG

Haskell , 73 67 66 ไบต์

p n=[last[x^i|i<-[1..n],x^i<=n]|x<-[2..n],all((>0).mod x)[2..x-1]]

ลองออนไลน์! การใช้งาน:

Prelude> p 50
[32,27,25,49,11,13,17,19,23,29,31,37,41,43,47]

แก้ไข: 6 ไบต์ปิดขอบคุณ Zgarb!

คำอธิบาย:

p n=[... x|x<-[2..n]                         ] -- list of all x in the range 2 to n
p n=[... x|x<-[2..n],        mod x<$>[2..x-1]] -- where the remainders of x mod the numbers 2 to x-1
p n=[... x|x<-[2..n],all(>0)$mod x<$>[2..x-1]] -- are all greater 0. This yields all primes in the range.

p n=[    [x^i|i<-[1..n]       ]|...] -- for each of those x generate the list of all x^i with i in the range 1 to n
p n=[last[x^i|i<-[1..n],x^i<=n]|...] -- where x^i is smaller or equal to n
p n=[last[x^i|i<-[1..n],x^i<=n]|...] -- and take the last (that is the largest) element

เยลลี่ขนาด 9 ไบต์

Ræl/ÆF*/€

หนึ่งไบต์ยาวกว่าคำตอบอื่น ๆ ของฉันแต่ป้อนข้อมูลเสร็จ10,000สองสามวินาที

ลองออนไลน์!

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

Ræl/ÆF*/€  Main link. Argument: n

R          Range; yield [1, ..., n].
 æl/       Reduce by least common multiple.
    ÆF     Factor the LCM into [prime, exponent] pairs.
      */€  Reduce each pair by exponentiation.

JavaScript (ES6), 118 120 119 114 112 105 ไบต์

(n,r)=>(r=k=>[...Array(k-1)].map((_,i)=>i+2),r(n).filter(q=>r(q).every(d=>q%d|!(d%(q/d)*(q/d)%d)&q*d>n)))

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

หมายเหตุ:

• จำนวนธรรมชาติ q คือพลังพิเศษ <=> ตัวหารทั้งหมดของ q คือพลังของนายกตัวเดียวกัน <=> สำหรับ d ใด ๆ ที่หาร q หนึ่งตัว d และ q / d เป็นตัวหารของอีกตัวหนึ่ง
• ถ้า q คือพลังของ p, q คือค่าสูงสุด <=> q ​​* p> n <=> q ​​* d> n สำหรับตัวหารที่ไม่เกี่ยวข้องทุกตัว d ของ q

Sage, 43 ไบต์

lambda i:[x^int(ln(i,x))for x in primes(i)]

แม็พแต่ละไพรม์ในช่วงprimes(i)ให้อยู่ในพาวเวอร์ไพร์มสูงสุด lnเป็นเพียงนามแฝงของlogมันจึงยอมรับฐานสำรองแม้ว่าชื่อของมันจะบอกว่ามันสามารถใช้ฐานeได้เท่านั้น

Haskell, 110 90 ไบต์

s[]=[];s(x:t)=x:s[y|y<-t,y`rem`x>0];f n=[last.fst.span(<=n).scanl1(*)$repeat x|x<-s[2..n]]

- ปรับปรุงตามความคิดเห็นของ Laikoni

Haskell , 70 ไบต์

f n=[k|k<-[2..n],p:q<-[[d|d<-[2..k],mod k d<1]],k==p*p^length q,p*k>n]

fกำหนดฟังก์ชั่น ลองออนไลน์!

คำอธิบาย

ความคิดคือการกรองช่วง[2..n]สำหรับตัวเลขผู้kที่ตอบสนองk == p^length(divisors k)และp*k > nที่เป็นตัวหารที่สำคัญที่สุดของpk

f n=                -- Define f n as
 [k|                -- the list of numbers k, where
  k<-[2..n],        -- k is drawn from [2..n],
  p:q<-[            -- the list p:q is drawn from
   [d|              -- those lists of numbers d where
    d<-[2..k],      -- d is drawn from [2..k] and
    mod k d<1]      -- d divides k
   ],               -- (so p:q are the divisors of k except 1, and p is the smallest one),
  k==p*p^length q,  -- k equals p to the power of the divisor list's length
                    -- (so it's in particular a prime power), and
  p*k>n]            -- p*k, the next power of p, is not in the range [2..n].

PHP, 101 93 91 88 ไบต์

เพียงคณิตศาสตร์จริงเล็กน้อย ...

for($n=$argv[$i=1];$n>$j=$i++;$j?:$r[$p=$i**~~log($n,$i)]=$p)for(;$i%$j--;);print_r($r);

ทำให้พังถล่ม

for($n=$argv[$i=1];     // loop $i from 2 to $n
    $n>$j=$i++;             // 0.: init $j to $i-1
    $j?:                    // 2. if $i is prime
        $r[$p=$i**~~log($n,$i)]=$p) // 3. add maximum power to results
    for(;$i%$j--;);         // 1. prime check (if $i is prime, $j will be 0)
print_r($r);            // print results

JavaScript ES7, 93 ไบต์

ซ้ำย้ำiจาก 0 nและรวมถึง ถ้าiเป็นนายกยกมันไปที่เลขชี้กำลังชั้นสูงสุดที่ทำให้มัน<= n( i ^ floor(log(n) / log(i)))

F=(n,i=n)=>i?[...((P=j=>i%--j?P(j):1==j)(i)?[i**((l=Math.log)(n)/l(i)|0)]:[]),...F(n,--i)]:[]