Sfida

Il tuo compito è scrivere un programma o una funzione che, dato un intero positivo N , trovi tutti gli interi positivi inferiori o uguali a N che possono essere espressi come potenza perfetta in più di un modo.

Definizione

Un potere perfetto è definito come un numero ho trovato da m ^ k , dove:

• m e i sono numeri interi positivi
• m! = k

Casi test

input -> output
1000 -> 16, 64, 81, 256, 512, 625, 729
56 -> 16
999 -> 16, 64, 81, 256, 512, 625, 729
81 -> 16, 64, 81
1500 -> 16, 64, 81, 256, 512, 625, 729, 1024, 1296

Fornisci anche una versione leggibile e commentata.

Mathematica: 103 caratteri

Gli spazi possono essere rimossi

Select[Flatten@
       Table[
        Solve[Log@#/Log@b == k, k, Integers] /. k -> #, {b, 2, #}] & /@ Range@#, 
Length@# > 2 &][[All, 1, 1]] &  

Uso:

%[81]
{16, 64, 81}

Jelly , 11 byte significativi, sfida postdatati in lingua

ḊḟÆR *@þ Ḋ  F  fḊ

Provalo online!

Ecco una soluzione completamente diversa. Questo è un curioso ibrido di efficiente e inefficiente, che utilizza un algoritmo core efficiente in un wrapper molto inefficiente (al punto che non è in grado di gestire numeri molto grandi). Come prima, tutto lo spazio bianco è insignificante.

Ecco come funziona. Ḋ(che appare più volte) è un elenco di numeri da 2 all'input incluso:

ḊḟÆR *@þ Ḋ  F  fḊ
ḊḟÆR                Ḋ, with all primes between 2 and the input removed
                    (i.e. all composite numbers from 4 to the input)
     *@þ Ḋ          Exponentiate all Ḋ elements with all ḊḟÆR elements
            F       Flatten the result (it had a nested structure)
               fḊ   Keep only elements in Ḋ

L'osservazione di base qui è che un numero è un potere perfetto in molti modi, solo se è un potere perfetto con un esponente composito (che non è 1). Generiamo un elenco di quelli in cui la base è da 2 all'input e l'esponente è un numero composto da 4 a input; questo è molto lento perché genera alcuni numeri davvero grandi, che sono tutti una risposta alla domanda. Quindi conserviamo solo le risposte che sono nel raggio d'azione.

Sarebbe facilmente possibile modificarlo in una risposta altamente efficiente, elaborando quale fosse la massima potenza nel raggio di azione e non ripetendo ulteriormente, ma sarebbero molti più byte, e questo è code-golf.

Perl: 68 caratteri

Ottiene il massimo (1000) $Ne restituisce la risposta @a.

for $x ( 2..$N ) {
    $c{$x**$_}++ for 2..log($N)/log$x
}
@a = grep { $c{$_} > 1 } keys %c

Per un intero programma, ho bisogno di altri 18 caratteri:

$m = shift;
for $x ( 2..$m ) {
    $c{$x**$_}++ for 2..log($m)/log$x
}
print join ' ', grep { $c{$_} > 1 } keys %c

Rubino - 101 caratteri (senza spazi bianchi)

f=->l{c=Hash.new{0}
2.upto(1E4){|i|2.upto(20){|j|c[i**j]+=1}}
c.map{|k,v|v>1&&k<=l&&k||p}.compact.sort}

Funziona per 1 <= limit <= 100,000,0005 secondi.

Test

> f[10000]
[16, 64, 81, 256, 512, 625, 729, 1024, 1296, 2401, 4096, 6561, 10000]

Jelly , 13 personaggi significativi, sfide post-lingua in lingua

R  µ  ọḊ *@Ḋ ċ >2  µ  Ðf

Provalo online!

Tutto lo spazio qui è insignificante. L'ho usato per mostrare la struttura della mia risposta, come fa la domanda.

Ecco come funziona:

R  µ  ọḊ *@Ḋ ċ >2  µ  Ðf
R                     Ðf    Find all numbers n from 1 to the input, such that:
   µ               µ          (grouping marks, like {} in C)
       Ḋ   Ḋ                  Take the range from 2 to n
      ọ                       Find the number of times each divides n
         *@                   Raise the range from 2 to n to these powers
             ċ                Count the number of times n appears
               >2             and the result must be greater than 2

Ad esempio, quando testiamo n = 256, controlliamo il numero di volte in cui ciascuno dei numeri da 2 a 256 si divide in 256. Gli unici numeri che dividono più di una volta sono 2 (che divide 8 volte), 4 (che divide 4 volte), 8 (che divide due volte) e 16 (che divide due volte). Quindi quando aumentiamo il numero di divisioni ai poteri lì determinati, otteniamo:

2⁸, 3, 4⁴, 5, 6, 7, 8², 9, 10, 11, 12, 13, 14, 15, 16², 17, ..., 255, 256

Questo produce il valore originale, 256, un numero di volte uguale al modo in cui 256 è una potenza perfetta, più uno (l'ultimo elemento produce 256 perché 256 = 256¹). Quindi, se ne vediamo 256 più di due volte nell'array (e in questo caso lo facciamo; 8² è 64 ma gli altri elementi "interessanti" producono tutti 256), deve essere un potere perfetto.