ท้าทาย

งานของคุณคือการเขียนโปรแกรมหรือฟังก์ชั่นซึ่งได้รับจำนวนเต็มบวกNพบจำนวนเต็มบวกทั้งหมดน้อยกว่าหรือเท่ากับNที่สามารถแสดงเป็นพลังที่สมบูรณ์แบบมากกว่าหนึ่งวิธี

คำนิยาม

พลังที่สมบูรณ์แบบถูกกำหนดให้เป็นตัวเลขที่ฉันพบโดยm ^ kโดยที่

• mและฉันเป็นจำนวนเต็มบวก
• m! = k

กรณีทดสอบ

อินพุต -> เอาต์พุต
1,000 -> 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

โปรดระบุรุ่นที่สามารถอ่านได้แสดงความคิดเห็นด้วย

Mathematica: 103 ตัวอักษร

สามารถลบช่องว่างได้

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

การใช้งาน:

%[81]
{16, 64, 81}

Jelly , 11 ไบต์ที่มีความหมาย, ภาษาโพสต์วันที่ท้าทาย

ḊḟÆR *@þ Ḋ  F  fḊ

ลองออนไลน์!

นี่คือทางออกที่แตกต่างอย่างสิ้นเชิง หนึ่งในนี้เป็นลูกผสมที่น่าสนใจของประสิทธิภาพและไม่มีประสิทธิภาพโดยใช้อัลกอริธึมหลักที่มีประสิทธิภาพในเสื้อคลุมที่ไม่มีประสิทธิภาพมาก (มากจนไม่สามารถจัดการกับตัวเลขที่มีขนาดใหญ่มาก) เมื่อก่อนช่องว่างทั้งหมดไม่มีความหมาย

นี่คือวิธีการทำงาน Ḋ(ซึ่งปรากฏหลายครั้ง) เป็นรายการของตัวเลขตั้งแต่ 2 ถึงอินพุตรวม:

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

การสังเกตพื้นฐานที่นี่คือตัวเลขเป็นพลังที่สมบูรณ์แบบในหลาย ๆ ทางเฉพาะในกรณีที่มันเป็นพลังที่สมบูรณ์แบบด้วยเลขชี้กำลังคอมโพสิต (นั่นไม่ใช่ 1) เราสร้างรายการของฐานที่มาจาก 2 ถึงอินพุตและเลขชี้กำลังเป็นจำนวนประกอบจาก 4 ถึงอินพุต; มันช้ามากเพราะมันสร้างตัวเลขจำนวนมากซึ่งทั้งหมดนี้เป็นคำตอบของคำถาม จากนั้นเราจะเก็บคำตอบที่อยู่ในช่วงเท่านั้น

มันเป็นไปได้อย่างง่ายดายที่จะแก้ไขสิ่งนี้ให้เป็นคำตอบที่มีประสิทธิภาพสูงโดยหาว่ากำลังสูงสุดในช่วงนั้นคืออะไรและไม่ทำซ้ำอีกต่อไป แต่นั่นจะเป็นจำนวนไบต์ที่มากขึ้นและนี่คือรหัสกอล์ฟ

Perl: 68 ตัวอักษร

ได้รับสูงสุด (1000) ในและส่งกลับคำตอบใน$N@a

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

สำหรับโปรแกรมทั้งหมดฉันต้องการอีก 18 ตัวอักษร:

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

Ruby - 101 chars (ไม่มีช่องว่าง)

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}

ใช้งานได้1 <= limit <= 100,000,000ภายใน 5 วินาที

ทดสอบ

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

Jelly , 13 ตัวละครที่มีความหมายภาษาโพสต์วันที่ท้าทาย

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

ลองออนไลน์!

ช่องว่างทั้งหมดที่นี่ไม่มีนัยสำคัญ ฉันใช้มันเพื่อแสดงโครงสร้างของคำตอบตามที่ถาม

นี่คือวิธีการทำงาน:

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

ตัวอย่างเช่นเมื่อทดสอบ n = 256 เราจะตรวจสอบจำนวนครั้งที่แต่ละตัวเลขจาก 2 ถึง 256 หารเป็น 256 ตัวเลขเท่านั้นที่หารมากกว่าหนึ่งครั้งคือ 2 (ซึ่งแบ่ง 8 ครั้ง), 4 (ซึ่งหาร 4 ครั้ง), 8 (ซึ่งหารสองครั้ง) และ 16 (ซึ่งหารสองครั้ง) ดังนั้นเมื่อเราเพิ่มจำนวนหน่วยงานเป็นอำนาจที่กำหนดไว้ที่นั่นเราจะได้รับ:

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

สิ่งนี้สร้างค่าดั้งเดิม 256 ครั้งจำนวนเท่ากับวิธีที่ 256 เป็นพลังที่สมบูรณ์แบบบวกหนึ่ง (องค์ประกอบสุดท้ายสร้าง 256 เพราะ 256 = 256¹) ดังนั้นถ้าเราเห็น 256 มากกว่าสองเท่าในอาเรย์ (และเราทำในกรณีนี้8²เป็น 64 แต่องค์ประกอบที่น่าสนใจอื่น ๆ ทั้งหมดผลิต 256) มันต้องเป็นพลังงานที่สมบูรณ์แบบ