소수는 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 의 최대 전력 인 경우, 최대 전력 p ^k 는 범위에서 최대 입니다 . 우리는 각 범위 의 최대 소수 에만 관심이 있으므로 모든 낮은 소수는 제외해야합니다.

당신의 목표는 양의 정수 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.

매스 매 티카, 44 43 40 바이트

마일과 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]대한 첫 번째 인수를 나타내는 short입니다 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는 ^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&@@@각 주문 쌍에 대해 첫 번째 요소를 두 번째 요소로 나눈 출력에 적용 합니다. (그들은 기본 프라임으로 정렬됩니다 {16, 9, 5, 7, 11, 13, 17, 19}. 예제 출력은 입니다.)

매스 매 티카, 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 사이에있는 것으로 가정). 따라서 남은 오른쪽 만 최대 최대 거듭 제곱입니다. 나머지 하나는 예외입니다 ( 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를 사용한 것은 이번이 처음이며, 더 짧은 방법으로 수행 할 수있는 작업이 있다는 것을 알고 있습니다.

{≥.~^ℕ₁ᵐ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는 세 개의 표시된 숫자 값 (각 줄 바꿈 문자)을 인쇄 한 다음 문자를 인쇄합니다 /^p. (bc에서 l (x)는 x의 자연 로그를 나타냅니다.) JK K

bc가 인쇄하는 문자열은 dc에 입력으로 공급됩니다. dc는 정수 산술 (잘림)을 사용하여 각 P ^ (log (N) / log (P))의 값을 인쇄합니다. 이것이 P의 최대 거듭 제곱 인 <= N입니다.

위에서 광택을 낸 것 중 하나는 소수에 해당하지 않는 요소에 의해 생성되는 선에 발생하는 것입니다. 이 줄은 sed 호출에서 정규식과 일치하지 않으므로 그 줄을 대체하지 않습니다. 결과적으로 해당 행은 숫자로 시작하고 뒤에 콜론이 오며 입력으로 공급 될 때 오류가 발생합니다 bc. 그러나 bc는 stderr에 인쇄합니다. 우리는 무시합니다. stdout에 아무것도 인쇄하지 않습니다. 기본적으로 stderr은 PPCG에서 무시됩니다 .

하스켈 , 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.

자바 스크립트 (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.

하스켈, 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]]

-라이 코니의 피드백에 따라 업데이트

하스켈 , 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

자바 스크립트 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)]:[]