Công suất nguyên tố là số nguyên dương n có thể được viết dưới dạng n = p ^k trong đó p là số nguyên tố và k là số nguyên dương. Ví dụ, một số quyền hạn chính là [2, 3, 5, 4, 9, 25, 8, 27, 125].

Tiếp theo, hãy xem xét các lũy thừa của 2. Đây là [2, 4, 8, 16, ...]và có thể được viết dưới dạng 2 ^k . Tất cả chúng sẽ được bao gồm khi xem xét các số nguyên tố dưới 20. Tuy nhiên, 16 là công suất nguyên tố cực đại có số nguyên tố cơ bản là 2 trong phạm vi đó. Công suất nguyên tố p ^k là cực đại trong một phạm vi nếu đó là công suất cao nhất của p trong phạm vi đó. Chúng tôi chỉ quan tâm đến công suất nguyên tố tối đa trong mỗi phạm vi nên tất cả các quyền lực thấp hơn phải được loại trừ.

Mục tiêu của bạn là viết một hàm hoặc chương trình lấy số nguyên dương n và xuất ra các lũy thừa cực đại trong phạm vi [2, 3, 4, ..., n].

Cảm ơn @ Peter Taylor đã làm rõ định nghĩa về sức mạnh nguyên tố tối đa và hơn thế nữa.

Quy tắc

• Đây là mã golf, vì vậy hãy làm cho mã của bạn càng ngắn càng tốt.
• Các quyền hạn tối đa có thể là đầu ra theo bất kỳ thứ tự nào nhưng không được có sự trùng lặp.

Các trường hợp thử nghiệm

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]

Danh sách đầy đủ các quyền hạn tối đa cho 10000 có thể được tìm thấy ở đây .

Thạch , 7 4 byte

æḟÆR

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

æḟÆ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.

Toán học, 44 43 40 byte

Saved 4 byte nhờ dặm và Martin Ender

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

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

⌊và ⌋là các 3ký tự byte U+230Avà U+230Bđại diện \[LeftFloor]và \[RightFloor], tương ứng.

Giải trình:

Chức năng thuần túy. #là viết tắt của từ Slot[1]này đại diện cho đối số đầu tiên cho Function. PrimePi@#đếm số lượng các số nguyên tố nhỏ hơn hoặc bằng #, Range@PrimePi@#là danh sách các PrimePi[#]số nguyên dương đầu tiên và Prime@Range@PrimePi@#danh sách các số nguyên tố nhỏ hơn hoặc bằng #(đây là một byte ngắn hơn Select[Range@#,PrimeQ]). Biểu tượng xlà Settương đương với danh sách này, sau đó nâng lên Power ⌊x~Log~#⌋, đó là danh sách Floor[Log[n,#]]cho mỗi ntrong x. Trong Mathematica, việc nâng một danh sách lên Powermột danh sách khác có cùng độ dài sẽ dẫn đến danh sách các quyền hạn của các phần tử tương ứng của chúng.

MATL, 13 byte

ZqG:!^tG>~*X>

Hãy thử trực tuyến!

Giải trình

        % 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

Thạch , 8 byte

ÆR*ÆE€»/

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Æ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.

Thạch , 12 9 byte

RÆEz0iṀ$€

Hãy thử trực tuyến! (phương pháp quá chậm đối với trường hợp 10000).

Làm sao?

Xây dựng danh sách p ^k theo thứ tự p .

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]

Bình thường, 13 byte

m^ds.lQdfP_TS

Hãy thử nó ở đây!

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

Tôi đã không chơi với Pyth trong một thời gian vì vậy mọi mẹo chơi gôn đều được đánh giá cao.

Tôi không thể có được một giải pháp Mathicala ngắn hơn giải pháp của ngenisis , nhưng tôi nghĩ rằng tôi sẽ đưa ra một vài cách tiếp cận thay thế (hy vọng thú vị).

Toán học, 65 byte

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

Đầu tiên chúng ta sử dụng {#,#}&/@Range@#~Select~PrimeQđể xây dựng một danh sách tất cả các số nguyên tố trong phạm vi thích hợp, nhưng với các cặp theo thứ tự của mỗi nguyên tố, như thế nào { {2,2}, {3,3}, ...}. Sau đó, chúng tôi hoạt động trên danh sách đó nhiều lần với quy tắc thay thế {a_,b_}/;a<=#:>{b a,b}, nhân số phần tử đầu tiên của cặp được đặt hàng thứ hai cho đến khi phần tử đầu tiên vượt quá đầu vào. Sau đó, chúng tôi áp dụng #/#2&@@@cho đầu ra, cho mỗi cặp theo thứ tự, phần tử đầu tiên chia cho phần thứ hai. (Chúng kết thúc được sắp xếp theo số nguyên tố cơ bản: một đầu ra ví dụ là {16, 9, 5, 7, 11, 13, 17, 19}.)

Toán học, 44 byte

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

Hàm von Mangoldt Λ(n)là một hàm lý thuyết số thú vị: nó bằng 0 trừ khi nlà công suất nguyên tố p ^k , trong trường hợp này bằng log p(không log n). (Đây là các bản ghi tự nhiên, nhưng nó không thành vấn đề.) Do đó MangoldtLambda@#->#&~Array~#tạo ra một mảng các quy tắc { 0->1, Log[2]->2, Log[3]->3, Log[2]->4, Log[5]->5, 0->6, ... }có độ dài là số nguyên đầu vào.

Sau đó chúng tôi biến danh sách các quy tắc này thành một "hiệp hội" bằng cách sử dụng <|...|>. Điều này có tác dụng chỉ giữ lại quy tắc cuối cùng với bất kỳ giá trị bên trái nào. Nói cách khác, nó sẽ vứt đi Log[2]->2và Log[2]->4và Log[2]->8chỉ giữ lại Log[2]->16(giả sử rằng đầu vào nằm trong khoảng từ 16 đến 31 cho ví dụ này). Do đó, các cạnh bên phải duy nhất còn lại là các số nguyên tố cực đại tối đa ngoại trừ một quy tắc còn lại 0->n, trong đó ncông suất không nguyên tố lớn nhất lên tới số nguyên đầu vào. Nhưng Restném quy tắc không mong muốn đó đi, và rút Valuesra các phía bên phải từ các quy tắc trong hiệp hội. (Họ cuối cùng được sắp xếp như trên.)

Phiên bản dài hơn một chút (46 byte), tính số lần xuất hiện của mỗi lần log pvà sau đó lũy thừa để chuyển đổi thành các quyền hạn tối đa:

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

CJam , 21 20 byte

Đã lưu 1 byte nhờ Martin Ender

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

Hãy thử trực tuyến!

Giải trình

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 byte

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

Hãy thử trực tuyến!

Điều này tạo ra các quyền hạn từ lớn nhất đến nhỏ nhất.

Điều này rất không hiệu quả.

Giải trình

⟧                   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

Điều này sẽ tìm thấy các phân tách nguyên tố lớn nhất cho mỗi nguyên tố đầu tiên vì cách thức ⊇hoạt động: từ trái sang phải và từ các tập con lớn nhất đến nhỏ nhất.

Brachylog , 24 21 19 byte

3 + 2 byte được lưu nhờ Fatalize!

Đây là lần đầu tiên tôi sử dụng Brachylog và tôi biết một số điều có thể đã được thực hiện theo những cách ngắn hơn, nhưng tôi rất vui vì nó thậm chí còn hoạt động: D

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

Hãy thử trực tuyến! (Giá trị trả về được sắp xếp theo số nguyên tố cơ sở của chúng)

Giải trình:

{................}ᶠ           #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 byte

ƒNpiN¹N.nïm,

Hãy thử trực tuyến!

Giải trình

ƒ             # 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

Tiện ích Bash + GNU, 74 byte

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

Hãy thử trực tuyến!

Số đầu vào được thông qua như là một đối số. Đầu ra được in ra thiết bị xuất chuẩn. (Theo thông lệ, stderr bị bỏ qua.)

Đầu ra mẫu:

./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

Đây là cách nó hoạt động:

Gọi đối số N.

seqtạo ra tất cả các số từ 1 đến N và factorcác yếu tố tất cả.

Regex trong lệnh gọi sed xác định các dòng trong đó số là số nguyên tố P và thay thế các dòng đó bằng các dòng có dạng `

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

(trong đó P và N được thay thế bằng các giá trị số thực tế của chúng và mọi thứ khác được sao chép theo nghĩa đen, thậm chí cả dấu ngoặc kép và dấu chấm phẩy và chuỗi print).

Những dòng này được cho ăn như đầu vào bc -l; bc in các giá trị của ba số được chỉ định, mỗi số được theo sau bởi một dòng mới và sau đó in các ký tự /^p. (Trong bc, l (x) biểu thị logarit tự nhiên của x.) JK K

Các chuỗi mà bc in sau đó được đưa vào làm đầu vào cho dc; dc in giá trị của mỗi P ^ (log (N) / log (P)) bằng số học số nguyên (cắt ngắn); đó là sức mạnh lớn nhất của P đó là <= N.

Một điều nổi bật ở trên là những gì xảy ra với các dòng được tạo ra bởi các yếu tố không tương ứng với các số nguyên tố. Những dòng này không khớp với regex trong lệnh gọi sed, vì vậy không có sự thay thế nào được thực hiện trên những dòng đó. Kết quả là, những dòng đó bắt đầu bằng một số theo sau là dấu hai chấm, tạo ra lỗi khi được đưa vào làm đầu vào bc. Nhưng bc chỉ in ra stderr sau đó, mà chúng tôi bỏ qua; nó không in bất cứ thứ gì để xuất bản. Theo mặc định, stderr được bỏ qua trên PPCG .

Haskell , 73 67 66 byte

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

Hãy thử trực tuyến! Sử dụng:

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

Chỉnh sửa: Tắt 6 byte nhờ Zgarb!

Giải trình:

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

Thạch , 9 byte

Ræl/ÆF*/€

Một byte dài hơn câu trả lời khác của tôi , nhưng kết thúc cho đầu vào 10.000 là vài giây.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

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

Gợi ý chào mừng. Đây là loại dài, nhưng nó có vẻ đáng đăng bởi vì nó thực hiện tất cả các thử nghiệm phân chia rõ ràng thay vì sử dụng tích hợp liên quan đến các số nguyên tố.

Ghi chú:

• Số tự nhiên q là lũy thừa nguyên tố <=> tất cả các ước của q là lũy thừa của cùng một số nguyên tố <=> cho bất kỳ d nào chia q, một trong d và q / d là ước của số khác.
• Nếu q là lũy thừa của p, q là cực đại <=> q ​​* p> n <=> q ​​* d> n với mọi ước số không cần thiết d của q.

Sage, 43 byte

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

Ánh xạ mỗi nguyên tố trong phạm vi primes(i)tới công suất nguyên tố cực đại của nó. lnchỉ là một bí danh logđể nó chấp nhận các cơ sở thay thế mặc dù tên của nó cho thấy nó chỉ có thể sử dụng cơ sở e.

Haskell, 110 90 byte

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

- phản hồi theo phản hồi của Laikoni

Haskell , 70 byte

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

Xác định một hàm f. Hãy thử trực tuyến!

Giải trình

Ý tưởng là để lọc phạm vi [2..n]cho những con số kthỏa mãn k == p^length(divisors k)và p*k > n, đâu plà ước số nguyên tố nhỏ nhất của k.

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 byte

chỉ là một chút toán học thực sự ...

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

phá vỡ

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 byte

Lặp lại đệ quy itừ 0 đến và bao gồm n. Nếu ilà số nguyên tố nâng nó lên số mũ nổi cao nhất làm cho nó <= 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)]:[]