质数幂是一个正整数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 ^ķ是最大的范围，如果它是最高功率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字节

感谢Miles和Martin Ender，节省了4个字节

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

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

⌊和⌋是3字节字符U+230A和U+230B表示\[LeftFloor]与\[RightFloor]分别。

说明：

纯功能。#的缩写Slot[1]，表示的第一个参数Function。PrimePi@#计算小于或等于的质数的数量#，Range@PrimePi@#是第一个PrimePi[#]正整数Prime@Range@PrimePi@#的列表，小于或等于#（小于的一个字节Select[Range@#,PrimeQ]）的质数的列表也是如此。符号x是Set等于该列表中，然后升高到Power ⌊x~Log~#⌋，这是该列表Floor[Log[n,#]]对于每个n在x。在Mathematica中，将一个列表提升到Power另一个相同长度的列表的结果，将得到其相应元素的幂的列表。

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Ṁ$€

在线尝试！（对于10000种情况，方法太慢了）。

怎么样？

生成的列表p ^ķ的顺序为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]

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玩过，所以任何打高尔夫球的技巧都值得赞赏。

我无法获得比ngenisis的解决方案更短的Mathematica解决方案，但是我认为我会提供几种（希望很有趣的）替代方法。

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]->2and Log[2]->4and Log[2]->8仅保留Log[2]->16（假设在此示例中，输入在16到31之间）。因此，剩下的唯一右侧是最大素数-剩下的一个规则除外0->n，其中，n是最大的非素数，直至输入整数。但是Rest将不想要的规则扔掉，并Values从关联中的规则中提取右侧。（它们最终按上述顺序排序。）

稍长一些（46字节）的版本，该版本计算每个版本的出现次数，log p然后取幂以转换为最大素数：

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

CJam，21 20字节

感谢Martin Ender，节省了1个字节

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字节

感谢Fatalize，节省了3 + 2个字节！

这是我第一次使用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

在线尝试！

输入数字作为参数传递。输出被打印到标准输出。（按照惯例，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它们全部分解。

sed调用中的regex标识那些数字为质数P的行，并将这些行替换为格式为`

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

（其中P和N替换为它们的实际数值，其他所有内容均按原样复制，甚至包括引号和分号以及字符串 print）。

这些行作为输入输入bc -l; bc打印三个指示数字的值，每个数字后跟换行符，然后打印字符/^p。（在bc中，l（x）表示x的自然对数。）JK K

然后将bc打印的字符串作为输入送入dc。dc使用整数运算（截断）打印每个P ^（log（N）/ log（P））的值；那是P的最大功效，即<=N。

上面掩盖的一件事是，由不与素数相对应的因子产生的线条发生了什么。这些行与sed调用中的正则表达式不匹配，因此不会替换这些行。结果，这些行以数字开头，后跟冒号，当输入时会产生错误bc。但是bc只是打印到stderr，我们忽略了；它不会打印任何东西到标准输出。默认情况下，在PPCG上忽略stderr。

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]

编辑：感谢Zgarb关闭6个字节！

说明：

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的除数都是除q的任意d的相同素数<=>的幂，d和q / d中的一个是另一个的除数。
• 如果q是p的幂，则对于q的每个非平分d，q都是最大<=> q * p> n <=> q * d> n。

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，其中p是最小的素因子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字节

只是一点点真正的数学...

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