Una potenza primaria è un numero intero n che può essere scritto nella forma n = p ^k dove p è un numero primo e k è un numero intero positivo. Ad esempio, alcuni poteri principali sono [2, 3, 5, 4, 9, 25, 8, 27, 125].

Quindi, considera i poteri primi di 2. Questi sono [2, 4, 8, 16, ...]e possono essere scritti nella forma 2 ^k . Sarebbero tutti inclusi quando si considerano le potenze primi inferiori a 20. Tuttavia, 16 è la massima potenza massima con un numero base base di 2 in tale intervallo. Una potenza primaria p ^k è massima in un intervallo se è la massima potenza di p in quell'intervallo. Siamo interessati solo alla massima potenza massima in ogni intervallo, quindi tutte le prime potenze inferiori devono essere escluse.

Il tuo obiettivo è quello di scrivere una funzione o un programma che accetta un numero intero positivo n e genera le potenze primi massime nell'intervallo [2, 3, 4, ..., n].

Grazie a @ Peter Taylor per aver chiarito la definizione di massima potenza primaria e altro ancora.

Regole

• Questo è code-golf, quindi rendi il tuo codice il più breve possibile.
• Le massime potenze prime possono essere emesse in qualsiasi ordine ma non devono esserci duplicati.

Casi test

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]

L'elenco completo delle massime potenze prime per 10000 è disponibile qui .

Gelatina , 7 4 byte

æḟÆR

Provalo online!

Come funziona

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

Risparmiato 4 byte grazie a miglia e Martin Ender

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

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

⌊e ⌋sono i 3caratteri byte U+230Ae che U+230Brappresentano \[LeftFloor]e \[RightFloor], rispettivamente.

Spiegazione:

Funzione pura. #è l'abbreviazione per Slot[1]cui rappresenta il primo argomento del Function. PrimePi@#conta il numero di numeri primi inferiori o uguali a #, Range@PrimePi@#è l'elenco dei primi PrimePi[#]numeri interi positivi, così Prime@Range@PrimePi@#come l'elenco di numeri primi inferiore o uguale a #(questo è un byte più corto di Select[Range@#,PrimeQ]). Il simbolo xè Setuguale a questo elenco, quindi elevato a Power ⌊x~Log~#⌋, che è l'elenco di Floor[Log[n,#]]per ciascuno nin x. In Mathematica, elevando un elenco a quello Powerdi un altro elenco della stessa lunghezza si ottiene l'elenco dei poteri dei loro elementi corrispondenti.

MATL, 13 byte

ZqG:!^tG>~*X>

Provalo online!

Spiegazione

        % 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

Gelatina , 8 byte

ÆR*ÆE€»/

Provalo online!

Come funziona

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

Gelatina , 12 9 byte

RÆEz0iṀ$€

Provalo online! (il metodo è troppo lento per il caso 10000).

Come?

Crea l'elenco di p ^k in ordine di 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 byte

m^ds.lQdfP_TS

Provalo qui!

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

Non gioco con Pyth da un po ', quindi sono apprezzati tutti i consigli sul golf.

Non sono riuscito a ottenere una soluzione Mathematica più breve della soluzione di ngenisi , ma ho pensato di offrire un paio di approcci alternativi (si spera interessanti).

Mathematica, 65 byte

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

Per prima cosa usiamo {#,#}&/@Range@#~Select~PrimeQper costruire un elenco di tutti i numeri primi nell'intervallo appropriato, ma con coppie ordinate di ciascun numero primo, come { {2,2}, {3,3}, ...}. Quindi operiamo su {a_,b_}/;a<=#:>{b a,b}quell'elenco ripetutamente con la regola di sostituzione , che moltiplica il primo elemento della coppia ordinata per il secondo fino a quando il primo elemento supera l'input. Quindi applichiamo #/#2&@@@all'output, per ogni coppia ordinata, il primo elemento diviso per il secondo. (Finiscono ordinati per primo sottostante: un esempio di output è {16, 9, 5, 7, 11, 13, 17, 19}.)

Mathematica, 44 byte

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

La funzione von Mangoldt Λ(n)è un'interessante funzione di teoria dei numeri: è uguale a 0 a meno che non nsia una potenza primaria p ^k , nel qual caso è uguale log p(non log n). (Questi sono registri naturali, ma non importa.) Quindi MangoldtLambda@#->#&~Array~#crea una matrice di regole la { 0->1, Log[2]->2, Log[3]->3, Log[2]->4, Log[5]->5, 0->6, ... }cui lunghezza è il numero intero di input.

Trasformiamo quindi questo elenco di regole in una "associazione" utilizzando <|...|>. Ciò ha l'effetto di mantenere solo l'ultima regola con un dato valore per la mano sinistra. In altre parole, verrà eliminato Log[2]->2ed Log[2]->4e Log[2]->8e solo Log[2]->16(supponendo che l'input sia compreso tra 16 e 31 per questo esempio). Pertanto gli unici lati di destra rimanenti sono i massimi poteri primari, ad eccezione dell'unica regola rimanente 0->n, dove nè il più grande potere non primario fino all'intero di input. Ma Restbutta via quella regola indesiderata ed Valuesestrae le parti di destra dalle regole dell'associazione. (Finiscono ordinati come sopra.)

Una versione leggermente più lunga (46 byte), che conta il numero di aspetti di ciascuno log pe quindi esponenzia per convertirsi ai massimi poteri primi:

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

CJam , 21 20 byte

Salvato 1 byte grazie a Martin Ender

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

Provalo online!

Spiegazione

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×ᵐ

Provalo online!

Questo produce i poteri dal più grande al più piccolo.

Questo è molto inefficiente.

Spiegazione

⟧                   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

Questo troverà le prime scomposizioni principali per ogni primo primo a causa del modo in cui ⊇funziona: da sinistra a destra e dai sottogruppi più grandi a quelli più piccoli.

Brachylog , 24 21 19 byte

3 + 2 byte salvati grazie a Fatalize!

Questa è la prima volta che uso Brachylog e so che alcune cose avrebbero potuto essere fatte in modi più brevi, ma sono felice che funzioni anche: D

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

Provalo online! (I valori di ritorno sono ordinati in base ai numeri primi di base)

Spiegazione:

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

Provalo online!

Spiegazione

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

Utilità Bash + GNU, 74 byte

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

Provalo online!

Il numero di input viene passato come argomento. L'output viene stampato su stdout. (Come al solito, stderr viene ignorato.)

Uscita campione:

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

Ecco come funziona:

Chiama l'argomento N.

seqgenera tutti i numeri da 1 a N e factorli considera tutti.

La regex nella chiamata a sed identifica quelle linee in cui il numero è una P primaria e sostituisce quelle linee con linee che sono della forma `

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

(dove P e N sono sostituiti dai loro valori numerici effettivi e tutto il resto viene copiato letteralmente, anche le virgolette, i punti e virgola e la stringa print).

Queste linee vengono alimentate come input per bc -l; bc stampa i valori dei tre numeri indicati, ciascuno seguito da una nuova riga, quindi stampa i caratteri /^p. (In bc, l (x) indica il logaritmo naturale di x.) JK K

Le stringhe che bc stampa vengono quindi alimentate come input per dc; dc stampa il valore di ogni P ^ (log (N) / log (P)) usando l'aritmetica intera (troncando); questa è la più grande potenza di P che è <= N.

Una cosa che è stata letta sopra è ciò che accade alle linee prodotte da fattori che non corrispondono ai numeri primi. Quelle linee non corrispondono al regex nella chiamata a sed, quindi non viene fatta alcuna sostituzione su quelle. Di conseguenza, queste linee iniziano con un numero seguito da due punti, che genera un errore quando viene immesso come input per bc. Ma bc stampa solo su Stderr allora, che ignoriamo; non stampa nulla su stdout. Per impostazione predefinita, stderr viene ignorato su 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]]

Provalo online! Uso:

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

Modifica: 6 byte di sconto grazie a Zgarb!

Spiegazione:

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

Gelatina , 9 byte

Ræl/ÆF*/€

Un byte più lungo dell'altra mia risposta , ma termina per l'ingresso 10.000 è un paio di secondi.

Provalo online!

Come funziona

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

Suggerimenti benvenuti. Questo è un po 'lungo, ma sembrava che valesse la pena pubblicarlo perché esegue esplicitamente tutti i test di divisibilità piuttosto che utilizzare gli incorporati relativi ai numeri primi.

Gli appunti:

• Un numero naturale q è un potere primo <=> tutti i divisori di q sono poteri dello stesso numero primo <=> per ogni d che divide q, uno di d e q / d è un divisore dell'altro.
• Se q è una potenza di p, q è massima <=> q ​​* p> n <=> q ​​* d> n per ogni divisore non banale d di q.

Sage, 43 byte

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

Mappa ogni numero primo nell'intervallo primes(i)alla sua massima potenza massima. lnè solo un alias di logquindi accetta basi alternative anche se il suo nome suggerisce che può usare solo base 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]]

- aggiornato secondo il feedback di 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]

Definisce una funzione f. Provalo online!

Spiegazione

L'idea è di filtrare l'intervallo [2..n]per quei numeri kche soddisfano k == p^length(divisors k)e p*k > n, dove pè il più piccolo divisore primo di 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

solo un po 'di vera matematica ...

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

abbattersi

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

Ripetere in modo ricorsivo ida 0 fino a incluso n. Se iè primo elevalo all'esponente con il piano più alto che lo rende <= 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)]:[]