Herausforderung

Ihre Aufgabe ist es, ein Programm oder eine Funktion zu schreiben, die bei einer positiven ganzen Zahl N alle positiven ganzen Zahlen kleiner oder gleich N findet, die auf mehr als eine Weise als perfekte Potenz ausgedrückt werden können.

Definition

Eine perfekte Kraft ist definiert als eine Zahl, die ich von m ^ k gefunden habe , wobei:

• m und ich sind positive ganze Zahlen
• m! = k

Testfälle

Eingabe -> Ausgabe
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

Bitte geben Sie auch eine lesbare, kommentierte Version an.

Mathematica: 103 Zeichen

Leerzeichen können entfernt werden

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

Verwendung:

%[81]
{16, 64, 81}

Jelly , 11 aussagekräftige Bytes, Sprachnachstellung

ḊḟÆR *@þ Ḋ  F  fḊ

Probieren Sie es online!

Hier ist eine ganz andere Lösung. Dies ist eine merkwürdige Mischung aus effizient und ineffizient, die einen effizienten Kernalgorithmus in einem sehr ineffizienten Wrapper verwendet (so sehr, dass er nicht mit sehr großen Zahlen umgehen kann). Alle Leerzeichen sind nach wie vor bedeutungslos.

So funktioniert das. Ḋ(was mehrmals vorkommt) ist eine Liste von Zahlen von 2 bis einschließlich der Eingabe:

ḊḟÆ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 Ḋ

Die grundlegende Beobachtung hier ist, dass eine Zahl in mehrfacher Hinsicht eine perfekte Potenz ist, nur wenn es sich um eine perfekte Potenz mit einem zusammengesetzten Exponenten handelt (der nicht 1 ist). Wir generieren eine Liste derer, bei denen die Basis von 2 bis zur Eingabe ist und der Exponent eine zusammengesetzte Zahl von 4 bis zur Eingabe ist. Das ist sehr langsam, weil es einige wirklich große Zahlen generiert, die alle eine Antwort auf die Frage sind. Dann behalten wir nur die Antworten, die in Reichweite sind.

Es wäre leicht möglich, dies in eine hocheffiziente Antwort umzuwandeln, indem man die maximale Reichweite berechnet und nicht weiter iteriert, aber das wären viel mehr Bytes, und das ist Code-Golf.

Perl: 68 Zeichen

Erhält das Maximum (1000) in $Nund gibt die Antwort in zurück @a.

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

Für ein ganzes Programm benötige ich noch 18 Zeichen:

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

Ruby - 101 Zeichen (ohne Leerzeichen)

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}

Funktioniert 1 <= limit <= 100,000,000innerhalb von 5 Sekunden.

Prüfung

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

Jelly , 13 bedeutungsvolle Charaktere, sprachliche Postdates herausfordern

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

Probieren Sie es online!

Alle Leerzeichen hier sind unbedeutend. Ich habe es benutzt, um die Struktur meiner Antwort zu zeigen, wie es in der Frage steht.

So funktioniert das:

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

Wenn wir zum Beispiel n = 256 testen, überprüfen wir, wie oft jede der Zahlen von 2 bis 256 in 256 geteilt wird. Die einzigen Zahlen, die mehr als einmal dividieren, sind 2 (die 8 mal dividieren), 4 (die 4 dividieren) mal), 8 (die zweimal teilt) und 16 (die zweimal teilt). Wenn wir also die Anzahl der Divisionen auf die dort festgelegten Kräfte erhöhen, erhalten wir:

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

Dies ergibt den ursprünglichen Wert 256, eine Anzahl von Malen, die der Art entspricht, wie 256 eine perfekte Potenz ist, plus eins (das letzte Element ergibt 256, weil 256 = 256¹). Wenn wir also 256 mehr als zweimal im Array sehen (und das tun wir in diesem Fall; 8² ist 64, aber die anderen "interessanten" Elemente produzieren alle 256), muss es eine perfekte Potenz sein.