素数の累乗は、n = p ^kの形式で記述できる正の整数nです。ここで、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バイト節約

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@#のリストも同様です（これは、1バイトより短い）。シンボルがあり、このリストに等しく、その後に上げのリストであり、各々のためには。Mathematicaでは、リストを同じ長さの別のリストに上げると、対応する要素のべき乗のリストになります。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Ṁ$€

オンラインでお試しください！（メソッドは10000の場合には遅すぎます）。

どうやって？

pの順にp ^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で遊んだことがないので、ゴルフのコツは大歓迎です。

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番目の要素を乗算します。次に#/#2&@@@、順序付けられたペアごとに、最初の要素を2番目の要素で割った値を出力に適用します。（それらは最終的な素数でソートされます：出力例は{16, 9, 5, 7, 11, 13, 17, 19}です。）

Mathematica、44バイト

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

フォン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の間であると仮定します）。従ってのみ残りの右辺は、最大の素数累乗-除く残りの1つのルールのためのものである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を呼び出します。

seq1からNまでのすべての数値を生成し、factorそれらすべてを因数分解します。

sedの呼び出しの正規表現は、数値が素数Pである行を識別し、それらの行を次の形式の行に置き換えます。

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

（ここで、PとNは実際の数値に置き換えられ、その他はすべて引用符やセミコロン、文字列も含めて文字通りコピーされますprint）。

これらの行は、への入力として供給されますbc -l。bcは、指定された3つの数字の値を出力し、それぞれに改行が続き、文字を出力します/^p。（bcでは、l（x）はxの自然対数を示します。）JK K

bcが出力する文字列は、dcへの入力として供給されます。dcは、整数演算（切り捨て）を使用して各P ^（log（N）/ log（P））の値を出力します。これは、Pの最大のパワーであり、<= Nです。

上記で説明したことの1つは、素数に対応しない要因によって生成される線に何が起こるかです。これらの行はsedの呼び出しの正規表現と一致しないため、これらの行の置換は行われません。結果として、これらの行は数字で始まり、その後にコロンが続きます。これは、への入力として供給されるとエラーを生成しますbc。ただし、bcはstderrに出力するだけなので、無視します。標準出力には何も出力しません。デフォルトでは、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]

編集： 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*/€

私の他の答えよりも1バイト長いですが、入力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はqのすべての非自明な除数dに対して最大<=> q * p> n <=> q * d> nです。

セージ、43バイト

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

範囲内の各素数primes(i)をその最大素数にマッピングします。lnは単なるエイリアスであるlogため、代替ベースを受け入れますが、その名前はbaseしか使用できないことを示唆しています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]]

-ライコニのフィードバックごとに更新

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

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バイト

i0からを含めて再帰的に繰り返し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)]:[]