Bir asal güç, n = p ^k biçiminde yazılabilecek pozitif bir tamsayıdır n , burada p , bir asaldır ve k , pozitif bir tamsayıdır. Örneğin, bazı asal güçler .[2, 3, 5, 4, 9, 25, 8, 27, 125]

Sonra, 2'nin ana güçlerini düşünün. Bunlar [2, 4, 8, 16, ...]2 ^k şeklindedir ve yazılabilir . Bunların hepsi, 20'nin altındaki asal güçler göz önüne alındığında dahil edileceklerdir. Ancak, 16, bu aralıktaki 2 temel üs ile maksimum asal güçtür. Bir ana güç p ^k , bu aralıktaki en yüksek p gücü ise bir aralıkta maksimumdur . Yalnızca her aralıktaki maksimum asal güç ile ilgileniyoruz, bu nedenle tüm düşük asal güçlerin hariç tutulması gerekiyor.

Amacınız pozitif bir tamsayı alır bir işlev veya program yazmaktır n ve çıkışlar maksimum aralıkta asal güçler [2, 3, 4, ..., n].

En yüksek asal güç tanımını ve daha fazlasını tanımlamak için @ Peter Taylor'a teşekkür ederiz .

kurallar

• Bu kod golfüdür, bu yüzden kodunuzu mümkün olduğunca kısa tutun.
• Maksimal asal güçler herhangi bir sırada çıkış olabilir ama hiçbir çiftleri olmalıdır.

Test durumları

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'e ait maksimum asal güçlerin tam listesi burada bulunabilir .

Jöle , 7 4 bayt

æḟÆR

Çevrimiçi deneyin!

Nasıl çalışı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 bayt

Mil ve Martin Ender sayesinde 4 byte kurtarıldı

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

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

⌊ve ⌋vardır 3bayt karakter U+230Ave U+230Btemsil \[LeftFloor]ve \[RightFloor]sırasıyla.

Açıklama:

Saf işlevi. #İçin KısaSlot[1]için ilk argümanı temsil edenFunction . PrimePi@#sayımları asal sayısı düşük veya hiç eşit #, Range@PrimePi@#birinci listesi aşağıdadır PrimePi[#]pozitif tamsayılar ve böylece Prime@Range@PrimePi@#asal listesi küçüktür veya eşit #(bundan daha bir byte kısadır Select[Range@#,PrimeQ]). Sembol xolup Setbu listede eşit, daha sonra yükseltilmiş Power ⌊x~Log~#⌋listesi olan Floor[Log[n,#]]her biri için nin x. Mathematica'da, Poweraynı uzunluktaki başka bir listenin listesini çıkarmak, karşılık gelen öğelerin güçlerinin listesiyle sonuçlanır.

MATL, 13 bayt

ZqG:!^tG>~*X>

Çevrimiçi Deneyin!

açıklama

        % 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

Jöle , 8 bayt

ÆR*ÆE€»/

Çevrimiçi deneyin!

Nasıl çalışır

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

Jöle , 12 9 bayt

RÆEz0iṀ$€

Çevrimiçi deneyin! (10000 durum için yöntem çok yavaş).

Nasıl?

Listesini oluşturur p ^k sırasına göre 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 bayt

m^ds.lQdfP_TS

Burada dene!

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

Bir süredir Pyth ile oynamamıştım, bu yüzden herhangi bir golf bahşesine değer veriliyor.

Ngenisis'in çözümünden daha kısa bir Mathematica çözümü bulamadım , ancak birkaç (umarım ilginç) alternatif yaklaşım önerebileceğimi düşündüm.

Mathematica, 65 bayt

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

Öncelikle {#,#}&/@Range@#~Select~PrimeQuygun aralıktaki tüm asalların bir listesini oluşturmak için kullanıyoruz , ancak her bir asalın sıralı çiftleri gibi { {2,2}, {3,3}, ...}. Ardından {a_,b_}/;a<=#:>{b a,b}, sıralanan çiftin ilk elemanını ilk eleman girdiyi geçinceye kadar ikinci ile çarpan değiştirme kuralı ile tekrar tekrar bu listede çalışırız . Sonra #/#2&@@@sırayla her bir çift için, ilk elemana bölünen ilk eleman olan çıktıya uygulanır . (Sonunda altta yatan prime göre sıralanırlar: örnek bir çıktı{16, 9, 5, 7, 11, 13, 17, 19} .)

Mathematica, 44 bayt

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

Von Mangoldt fonksiyonu Λ(n)ilginç sayılar teorisi fonksiyonudur: sürece 0 eşittir nbir asal güç p ^k o eşittir, bu durumda, log p(değil log n). (Bunlar doğal kütüklerdir, ancak önemi yoktur.) Böylece uzunluğu tamsayı olan MangoldtLambda@#->#&~Array~#bir dizi kural oluşturur { 0->1, Log[2]->2, Log[3]->3, Log[2]->4, Log[5]->5, 0->6, ... }.

Daha sonra bu kurallar listesini kullanarak “ilişkilendirme” ye dönüştürüyoruz <|...|>. Bu, yalnızca son kuralı herhangi bir sol el değerinde tutma etkisine sahiptir. Başka bir deyişle, atmak olacak Log[2]->2ve Log[2]->4ve Log[2]->8ve sadece tutmak Log[2]->16(giriş bu örnek için 16 ile 31 arasında olduğunu varsayarak). Bu nedenle, sadece kalan sağ taraf maksimal asal güçler-dışında kalan tek kural içindir 0->n, ngiriş tamsayıya olmayan en büyük asal-gücü kadardır. Fakat Restbu istenmeyen kuralı ortadan Valueskaldırır ve sağ tarafları dernek kurallarından çıkarır. (Yukarıdaki gibi sıralanırlar.)

Her birinin görünüş sayısını sayan log pve daha sonra en yüksek asal güçlere dönüştürülecek şekilde üsteleyen biraz daha uzun (46 bayt) bir sürüm :

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

CJam , 21 20 bayt

Martin Ender sayesinde 1 bayt kaydedildi

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

Çevrimiçi deneyin!

açıklama

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 bayt

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

Çevrimiçi deneyin!

Bu, güçleri en büyüğünden en küçüğüne çıkarır.

Bu çok verimsiz.

açıklama

⟧                   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

Bu, şu şekilde ⊇çalıştığı için her asal için en büyük asal ayrışımları bulacak : soldan sağa ve en büyükten en küçük alt gruplara.

Brachylog , 24 21 19 bayt

Fatalize sayesinde 3 + 2 bayt kaydedildi!

Bu benim ilk kez Brachylog kullanıyorum ve bazı şeylerin daha kısa yollarla yapılabileceğini biliyorum, ancak çalıştığı için mutluyum: D

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

Çevrimiçi deneyin! (Dönüş değerleri, temel astarlarına göre sıralanmıştır)

Açıklama:

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

ƒNpiN¹N.nïm,

Çevrimiçi deneyin!

açıklama

ƒ             # 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 yardımcı programları, 74 bayt

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

Çevrimiçi deneyin!

Giriş numarası bir argüman olarak iletilir. Çıktı stdout'a yazdırılır. (Geleneksel olduğu gibi, stderr yoksayılır.)

Örnek çıktı:

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

İşte nasıl çalışıyor:

Argümanı N olarak adlandır.

seq1'den N'ye kadar olan tüm sayıları üretir ve factorhepsini etkiler.

Sed çağrısındaki regex, sayının asal P olduğu satırları tanımlar ve bu satırları formdaki satırlarla değiştirir.

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

(burada P ve N, gerçek sayısal değerleriyle değiştirilir ve diğer her şey kelimenin tam anlamıyla, tırnak işaretleri, noktalı virgüller ve dize bile kopyalanır print).

Bu satırlar girdi olarak beslenir bc -l; bc, her biri bir yeni satır izleyen belirtilen üç sayının değerlerini ve ardından karakterleri yazdırır /^p. (Bc, l (x), x'in doğal logaritmasını gösterir.) JK K

Bc yazdıran dizeler daha sonra dc girişine beslenir; dc, tamsayı aritmetiğini (kesme) kullanarak her P ^ (log (N) / log (P)) değerini yazdırır; P = 'nin en büyük gücü <= N'dir.

Yukarıda belirtilen bir şey, astarlara karşılık gelmeyen faktörlerin ürettiği çizgilere ne olduğudur. Bu çizgiler çağrıdaki regex ile eşleşmiyor, bu yüzden bunlar üzerinde değişiklik yapılmıyor. Sonuç olarak, bu satırlar, bir sayı ile başlar ve bunu girişte beslendiğinde hata oluşturan bir kolon izler bc. Fakat bc sadece görmezden geldiğimiz için stderr'e basar; stdout'a hiçbir şey basmaz. Varsayılan olarak, stderr PPCG'de yoksayılır .

Haskell , 73 67 66 bayt

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

Çevrimiçi deneyin! Kullanımı:

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

Düzenleme: Zgarb sayesinde 6 bayt kapalı!

Açıklama:

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

Jöle , 9 bayt

Ræl/ÆF*/€

Bir cevabım diğer cevabımdan daha uzun , fakat 10.000 giriş için bitti birkaç saniye.

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

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

Önerilerinizi bekliyoruz. Bu biraz uzun, ancak kayıtlara değer gibi görünüyordu çünkü tüm bölünebilirlik testlerini, astarlarla ilgili yerleşikleri kullanmak yerine açıkça kullanıyor.

Notlar:

• Doğal sayı q, asal bir güçtür <=> q'nun bölenlerinin tümü, q, d ve q / d'den birinin diğerinin böleni olduğu her d için aynı asıl gücün <=> gücüdür.
• Q, p'nin gücü ise, q, q'nun önemsiz her bölen d'si için, maksimum <=> q ​​* p> n <=> q ​​* d> n'dir.

Adaçayı, 43 bayt

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

Aralıktaki her bir primi primes(i)maksimum primer gücüyle eşler. lnsadece bir diğer adıdır, logbu nedenle alternatif üsleri kabul eder, ancak adı yalnızca üs kullanabileceğini gösterir e.

Haskell, 110 90 bayt

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'nin geri bildirimlerine göre güncel

Haskell , 70 bayt

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

Bir fonksiyon tanımlar f. Çevrimiçi deneyin!

açıklama

Buradaki fikir, [2..n]bu sayıların aralığını ve en küçük ana bölenin nerede kolduğunu filtrelemektir .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 bayt

Sadece biraz gerçek matematik ...

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

Yıkmak

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 bayt

Özyinelemeli i0 ila dahil olmak üzere yineleyin n. iAsal ise , onu yapan en yüksek katlı üsse yükseltin <= 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)]:[]