Un potere perfetto è un numero della forma a**b, dove a>0e b>1.

Ad esempio, 125è un potere perfetto perché può essere espresso come 5**3.

Obbiettivo

Il tuo compito è quello di scrivere un programma / funzione che trovi l' nennesima potenza perfetta, dato un numero intero positivo n.

Specifiche

• Il primo potere perfetto è 1(che è 1**2).
• Input / output in qualsiasi formato ragionevole.
• Sono ammessi gli incorporati .

Ulteriori informazioni

• OEIS A001597

punteggio

Questo è code-golf . Vince la soluzione più breve in byte.

Casi test

input  output
1      1
2      4
3      8
4      9
5      16
6      25
7      27
8      32
9      36
10     49

Gelatina , 11 byte

µÆE;¬g/’µ#Ṫ

Provalo online! .

sfondo

Ogni intero positivo k può essere fattorizzato in modo univoco come il prodotto di potenze dei primi m primi, ovvero k = p ₁ ^{α ₁} ⋯ p _m ^{α _m} , dove α _m > 0 .

Abbiamo che a ^b ( b> 1 ) per un numero intero positivo a se e solo se b è un divisore di tutti gli esponenti α _j .

Pertanto, un intero k> 1 è un potere perfetto se e solo se gcd (α ₁ , ⋯, α _m ) ≠ 1 .

Come funziona

µÆE;¬g/’µ#Ṫ  Main link. No arguments.

µ            Make the chain monadic, setting the left argument to 0.
        µ#   Find the first n integers k, greater or equal to 0, for which the
             preceding chain returns a truthy value.
             In the absence of CLAs, n is read implicitly from STDIN.
 ÆE          Compute the exponents of the prime factorization of k.
   ;¬        Append the logical NOT of k, i.e., 0 if k > 0 and 1 otherwise.
             This maps 1 -> [0] and [0] -> [1].
     g/      Reduce the list of exponents by GCD.
             In particular, we achieved that 1 -> 0 and 0 -> 1.
       ’     Decrement; subtract 1 from the GCD.
             This maps 1 to 0 (falsy) and all other integers to a truthy value.
          Ṫ  Tail; extract the last k.

Mathematica, 34 byte

(Union@@Array[#^#2#&,{#,#}])[[#]]&

Genera un n × n matrice A _ij = i ^{1+ j} , appiattisce, e ritorna il n -esimo elemento.

CJam, 16 byte

ri_),_2f+ff#:|$=

Provalo qui.

Spiegazione

Questo utilizza un'idea simile alla risposta Mathematica di LegionMammal.

ri    e# Read input and convert to integer N.
_),   e# Duplicate, increment and turn into range [0 1 ... N].
_2f+  e# Duplicate and add two to each element to get [2 3 ... N+2].
ff#   e# Compute the outer product between both lists over exponentiation.
      e# This gives a bunch of perfect powers a^b for a ≥ 0, b > 1.
:|    e# Fold set union over the list, getting all unique powers generated this way.
$     e# Sort them.
=     e# Retrieve the N+1'th power (because input is 1-based, but CJam's array access
      e# is 0-based, which is why we included 0 in the list of perfect powers.

Ottava, 57 31 30 byte

@(n)unique((1:n)'.^(2:n+1))(n)

Ho appena notato di nuovo che Octave non ha bisogno ndgrid(mentre Matlab lo fa) =)

05AB1E , 12 byte

Codice:

LD>m€`{Ú`¹<@

Utilizza la codifica CP-1252 . Provalo online! .

Sage (versione 6.4, probabilmente anche altri): 64 63

lambda n:[k for k in range(1+n^2)if(0+k).is_perfect_power()][n]

Crea una funzione lambda che restituisce nla potenza perfetta. Facciamo affidamento sul fatto che si trova all'interno dei primi n^2numeri interi. ( 1+n^2È necessario per n=1,2. Il 0+kbit è necessario per convertire int(k)in Integer(k).)

Arrivederci per xrange-> range, grazie Dennis.

Solo un fatto divertente: 0è un potere perfetto per gli standard di Sage, per fortuna, perché allora 1è il 1 ° elemento della lista, non 0 ° :)

Pyth - 12 11 byte

Approccio ovvio, passa e controlla tutti i numeri.

e.ffsI@ZTr2

Test Suite .

MATL, 9 byte

:tQ!^uSG)

Provalo online

Questa è una porta della soluzione Octave di Flawr per MATL, aumentare la matrice dei poteri n^(n+1)e ottenere la nterza.

Julia, 64 32 byte

n->sort(∪([1:n]'.^[2:n+1]))[n]

Questa è una funzione anonima che accetta un numero intero e restituisce un numero intero. Per chiamarlo, assegnarlo a una variabile.

L'idea qui è la stessa in Mathematica di LegionMammal risposta : Prendiamo il prodotto esterno degli interi da 1 a n con 2 a n + 1, comprimere la matrice risultante colonna-saggio, prendere elementi unici, ordinare e ottenere il n ^esimo elemento .

Provalo online! (include tutti i casi di test)

JavaScript (ES6), 87

n=>(b=>{for(l=[i=0,1];b<n*n;++b)for(v=b;v<n*n;)l[v*=b]=v;l.some(x=>n==i++?v=x:0)})(2)|v

Meno golf

f=n=>{
  for(b=2, l=[0,1]; b < n*n; ++b)
    for(v = b; v < n*n;)
      l[v*=b] = v;
  i = 0;
  l.some(x => n == i++ ? v=x : 0);
  return v;
  // shorter alternative, but too much memory used even for small inputs
  // return l.filter(x=>x) [n-1];
}

Test

f=n=>(b=>{for(l=[i=0,1];b<n*n;++b)for(v=b;v<n*n;)l[v*=b]=v;l.some(x=>n==i++?v=x:0)})(2)|v

function test(){
  var v=+I.value
  O.textContent=f(v)
}
  
test()

<input type=number id=I value=10><button onclick='test()'>-></button>
<span id=O></span>

In realtà, 18 byte (non concorrenti)

;;u@ⁿr;`;√≈²=`M@░E

Provalo online!(potrebbe non funzionare a causa della necessità di un aggiornamento)

Questa soluzione non è competitiva perché ho corretto un bug con E dopo che questa sfida era stata pubblicata.

Spiegazione:

;;u@ⁿr;`;√≈²=`M@░E
;;u@ⁿr              push range(n**(n+1))
      ;`;√≈²=`M@░   filter: take if
        ;√≈²=         int(sqrt(x))**2 == x
                 E  get nth element

> <>, 108 byte

:1)?v  >n;
$:@@\&31+2>2$:@@:@
:1=?\@$:@*@@1-
:~$~<.1b+1v!?(}:{:~~v?(}:{:v?=}:{
1-:&1=?v~~>~61.     >~1+b1.>&

Questo programma richiede che il numero di input sia presente nello stack prima di essere eseguito.

Ci è voluto parecchio per ridurre il numero di byte sprecati a 7!

Dopo un controllo per vedere se l'ingresso è 1, il programma controlla ogni numero n, da 4 a sua volta per vedere se è una potenza perfetta. Lo fa iniziando con a=b=2. Se a^b == nabbiamo trovato un potere perfetto, quindi diminuisci il numero di poteri perfetti che resta da trovare - se abbiamo già trovato il numero giusto, produci.

Se a^b < n, bviene incrementato. Se a^b > n, aviene incrementato. Quindi, se a == n, abbiamo scoperto che nnon è una potenza perfetta, quindi incrementa n, ripristina ae b.

J, 29 byte

Basato sul metodo di @ LegionMammal978 .

<:{[:/:~@~.[:,/[:(^/>:)~>:@i.

uso

   f =: <:{[:/:~@~.[:,/[:(^/>:)~>:@i.
   f " 0 (1 2 3 4 5 6 7 8 9 10)
1 4 8 9 16 25 27 32 36 49

Spiegazione

<:{[:/:~@~.[:,/[:(^/>:)~>:@i.
                           i.  Create range from 0 to n-1
                        >:     Increments each in that range, now is 1 to n
               [:              Cap, Ignores input n
                    >:         New range, increment from previous range to be 2 to n+1 now
                  ^/           Forms table using exponentation between 1..n and 2..n+1
             ,/                Flattens table to a list
         ~.                    Takes only distinct items
     /:~                       Sorts the list
<:                             Decrements the input n (since list is zero-based index)
  {                            Selects value from resulting list at index n-1

JavaScript (ES7), 104 byte

n=>(a=[...Array(n)]).map(_=>a.every(_=>(p=i**++j)>n*n?0:r[p]=p,i+=j=1),r=[i=1])&&r.sort((a,b)=>a-b)[n-1]

Funziona calcolando tutti i poteri non maggiori di n², ordinando l'elenco risultante e prendendo l'ennesimo elemento.

Java, 126

r->{int n,i,k;if(r==1)return r;for(n=i=2,r--;;){for(k=i*i;k<=n;k*=i)if(k==n){i=--r>0?++n:n;if(r<1)return n;}if(--i<2)i=++n;}}