เพื่อนปัจจัยที่สำคัญ


21

ได้รับจำนวนเต็มN > 1ออกหมายเลขอื่น ๆ Nที่สลายตัวที่สำคัญมีตัวเลขเดียวกับการสลายตัวที่สำคัญของ

ตัวอย่างเช่นถ้าN = 117ผลลัพธ์จะต้องเป็น[279, 939, 993, 3313, 3331]เพราะ

117 = 3 × 3 × 13

ดังนั้นตัวเลขที่มีอยู่มี1, 3, 3และ3และเรามี

279  = 3 × 3 × 31
939  = 3 × 313
993  = 3 × 331
3313 = 3313
3331 = 3331

ตัวเลขเหล่านี้เป็นตัวเลขที่เป็นไปได้อื่น ๆ เท่านั้นเนื่องจากการรวมกันของตัวเลขเหล่านี้จะทำให้ได้จำนวนเต็มที่ไม่ใช่ไพร์มซึ่งไม่สามารถเป็นผลมาจากการแยกตัวประกอบเฉพาะ

ถ้าNใด ๆ ของ117, 279, 939, 993, 3313หรือ3331แล้วออกจะมีห้าตัวเลขอื่น ๆ : พวกเขาเป็นนายกเพื่อนปัจจัย

คุณไม่สามารถใช้ศูนย์นำหน้าเพื่อรับช่วงเวลาเช่นสำหรับN = 107เพื่อนเพียงคนเดียวของมันคือ701( 017ไม่ได้รับการพิจารณา)

อินพุตและเอาต์พุต

  • เพื่อนอินพุตและเอาต์พุตต้องถูกนำมาใช้และส่งคืนในฐานสิบ

  • Nจะยิ่งใหญ่กว่า1เสมอ

  • เอาต์พุตสามารถจัดรูปแบบได้ค่อนข้างอิสระตราบใดที่มันมีเฉพาะองค์ประกอบเพื่อนและตัวคั่น / รายการองค์ประกอบประโยค

  • การเรียงลำดับของเอาต์พุตไม่สำคัญ

  • คุณอาจรับอินพุตSTDINเป็นอาร์กิวเมนต์ของฟังก์ชันหรือสิ่งอื่นที่คล้ายคลึงกัน

  • คุณอาจพิมพ์ผลลัพธ์ไปที่STDOUTส่งคืนจากฟังก์ชันหรือสิ่งอื่นที่คล้ายคลึงกัน

กรณีทดสอบ

โปรแกรมของคุณควรจะแก้ปัญหาใดกรณีทดสอบด้านล่างในน้อยกว่าหนึ่งนาที

N        Buddies
2        []
4        []
8        []
15       [53]
16       []
23       [6]
42       [74, 146, 161]
126      [222, 438, 483, 674, 746, 851, 1466, 1631, 1679]
204      [364,548,692,762,782,852,868,1268,1626,2474,2654,2921,2951,3266,3446,3791,4274,4742,5426,5462,6233,6434,6542,7037,8561,14426,14642,15491,15833,22547]

เกณฑ์การให้คะแนน

นี่คือดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ

คำตอบ:


4

เยลลี่ขนาด 14 ไบต์

ÆfVṢṚḌ
ÇÇ€=ÇTḟ

เวลาดำเนินการอาจลดลงครึ่งหนึ่งด้วยDFแทนVแต่ก็ยังคงเสร็จสิ้นกรณีทดสอบที่รวมกันภายในไม่ถึงสามสิบวินาที

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

มันทำงานอย่างไร

ÆfVṢṚḌ   Helper link. Argument: k (integer)

Æf       Decompose k into an array of primes with product k.
  V      Eval. Eval casts a 1D array to string first, so this computes the integer
         that results of concatenating all primes in the factorization.
   Ṣ     Sort. Sort casts a number to the array of its decimal digits.
    Ṛ    Reverse. This yields the decimal digits in descending order.
     Ḍ   Undecimal; convert the digit array from base 10 to integer.


ÇÇ€=ÇTḟ  Main link. Argument: n (integer)

Ç        Call the helper link with argument n.
         This yields an upper bound (u) for all prime factorization buddies since
         the product of a list of integers cannot exceed the concatenated integers.
 ǀ      Apply the helper link to each k in [1, ..., u].
    Ç    Call the helper link (again) with argument n.
   =     Compare each result to the left with the result to the right.
     T   Truth; yield all 1-based indices of elements of [1, ..., u] (which match
         the corresponding integers) for which = returned 1.
      ḟ  Filter; remove n from the indices.

ฉันคิดว่าÇ€=$มันจะเร็วกว่าสักหน่อยÇ€=Çเนื่องจากมีข้อ จำกัด ด้านเวลา
Erik the Outgolfer

ขอบคุณ แต่สำหรับอินพุท117การปรับปรุงของคุณหมายถึงลิงค์ผู้ช่วยเหลือจะถูกเรียกว่า 3331 ครั้งแทนที่จะเป็น 3332 ครั้งดังนั้นการเพิ่มความเร็วจึงไม่สามารถวัดได้ อย่างไรก็ตาม TIO ที่ใหม่กว่า (เร็วกว่า) ไม่ต้องการแม้แต่ 20 วินาทีสำหรับการทดสอบแบบรวม
Dennis

16

PowerShell v3 +, 450 ไบต์

param($n)function f{param($a)for($i=2;$a-gt1){if(!($a%$i)){$i;$a/=$i}else{$i++}}}
$y=($x=@((f $n)-split'(.)'-ne''|sort))|?{$_-eq(f $_)}
$a,$b=$x
$a=,$a
while($b){$z,$b=$b;$a=$a+($a+$y|%{$c="$_";0..$c.Length|%{-join($c[0..$_]+$z+$c[++$_..$c.Length])};"$z$c";"$c$z"})|select -u}
$x=-join($x|sort -des)
$l=@();$a|?{$_-eq(f $_)}|%{$j=$_;for($i=0;$i-le$x;$i+=$j){if(0-notin($l|%{$i%$_})){if(-join((f $i)-split'(.)'|sort -des)-eq$x){$i}}}$l+=$j}|?{$_-ne$n}

ที่สุด!

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

PS C:\Tools\Scripts\golfing> Measure-Command {.\prime-factors-buddies.ps1 204}

Days              : 0
Hours             : 0
Minutes           : 0
Seconds           : 27
Milliseconds      : 114
Ticks             : 271149810
TotalDays         : 0.000313830798611111
TotalHours        : 0.00753193916666667
TotalMinutes      : 0.45191635
TotalSeconds      : 27.114981
TotalMilliseconds : 27114.981

คำอธิบาย

มีหลายอย่างเกิดขึ้นที่นี่ดังนั้นฉันจะพยายามทำลายมัน

บรรทัดแรกรับอินพุต$nและกำหนด a function,f ,ฟังก์ชั่นนี้ใช้ส่วนการทดลองแบบสะสมเพื่อหาปัจจัยที่สำคัญ มันค่อนข้างเร็วสำหรับอินพุตขนาดเล็ก แต่เห็นได้ชัดว่าหล่นลงมาถ้าอินพุตมีขนาดใหญ่ โชคดีที่กรณีทดสอบทั้งหมดมีขนาดเล็กดังนั้นจึงเพียงพอ

บรรทัดถัดไปได้รับfของนักแสดง$n, -splits พวกเขาในหลักไม่สนใจผลการว่างใด ๆ (นี่เป็นสิ่งจำเป็นเนื่องจากวิธีการ PowerShell จับคู่ regex และวิธีการที่มันเคลื่อนตัวชี้ผ่านเข้าและเป็นที่น่ารำคาญครับสำหรับการเล่นกอล์ฟวัตถุประสงค์) ทุกแล้วsorts ผล ตามลำดับ เราเก็บอาร์เรย์ของตัวเลขนั้นไว้$xและใช้สิ่งนั้นเป็นอินพุตของ|?{...}ตัวกรองเพื่อดึงเฉพาะตัวเลขที่เป็นตัวหลัก ตัวเลขหลักเหล่านั้นจะถูกเก็บไว้$yเพื่อใช้ในภายหลัง

จากนั้นเราก็แบ่งออก$xเป็นสองส่วน ครั้งแรก (กล่าวคือมีขนาดเล็กที่สุด) หลักคือการเก็บไว้ในขณะที่ส่วนที่เหลือจะถูกส่งผ่านเข้ามา$a $bหาก$xมีเพียงหนึ่งหลักก็$bจะว่าง / ไม่มีค่า จากนั้นเราจำเป็นต้องส่งใหม่$aเป็นอาร์เรย์ดังนั้นเราจึงใช้ตัวดำเนินการคอมม่าอย่างรวดเร็ว

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

ตราบใดที่มีองค์ประกอบที่เหลืออยู่ใน$bเราลอกออกหลักแรกเข้าและออกจากที่เหลืออยู่ใน$z $bจากนั้นเราจำเป็นต้องสะสมเป็น$aผลมาจากการแบ่งสตริงและหั่นบาง ๆ เราจะใช้$a+$yเป็นแถวเรียงต่อกันและสำหรับแต่ละองค์ประกอบที่เราสร้างสตริงใหม่$cแล้วห่วงผ่าน$c's .lengthและแทรก$zเข้าไปในทุกตำแหน่งรวมทั้ง prepending $z$cและท้าย$c$zแล้วselectไอเอ็นจีเพียง-uองค์ประกอบ nique ที่เชื่อมต่ออีกครั้งกับอาร์เรย์$aและจัดเก็บอีกครั้งกลับเข้า$aมา ใช่นี่จะจบลงเมื่อมีสิ่งที่โง่เขลาเกิดขึ้นเช่นคุณจะได้รับ3333ข้อมูล117ซึ่งไม่ใช่การเปลี่ยนแปลงที่เกิดขึ้นจริง แต่สิ่งนี้สั้นกว่าความพยายามกรองอย่างชัดเจนเพื่อให้แน่ใจว่าเราได้รับการเปลี่ยนแปลงทุกครั้งและช้าลงเล็กน้อยมาก

ดังนั้นตอนนี้$aมีอาร์เรย์ของการเปลี่ยนลำดับ (และบางส่วน) ที่เป็นไปได้ทั้งหมดของตัวเลขของปัจจัย เราจำเป็นต้องตั้งค่าใหม่$xให้เป็นขอบเขตสูงสุดของผลลัพธ์ที่เป็นไปได้โดย|sortส่งตัวเลขใน-desลำดับการส่งและ-joinนำกลับมารวมกัน เห็นได้ชัดว่าไม่มีมูลค่าส่งออกเกินกว่าจำนวนนี้

เราตั้งค่าตัวช่วยของเรา$lเป็นค่าที่เราเคยเห็น ต่อไปเราจะดึงค่าทุกค่าจาก$a(เช่นการเรียงสับเปลี่ยน) ที่ดีเยี่ยมและเข้าสู่ลูปที่เป็นช่วงเวลาที่ยิ่งใหญ่ที่สุดของโปรแกรมทั้งหมด ...

ทุกย้ำเราจะวนลูปจาก0การที่ถูกผูกไว้ด้านบนของเรา$x, $jการเพิ่มโดยองค์ประกอบปัจจุบัน ตราบใดที่$iค่าที่เรากำลังพิจารณาไม่ใช่ค่าก่อนหน้านี้หลายค่า (นั่นคือ0-notin($l|%{$i%$_})ส่วน) ก็เป็นตัวเลือกที่เป็นไปได้สำหรับผลลัพธ์ ถ้าเราใช้fนักแสดง$i, sortพวกเขาและพวกเขา-eqUAL $xแล้วเพิ่มมูลค่าให้กับท่อ ในตอนท้ายของการวนซ้ำเราเพิ่มองค์ประกอบปัจจุบันของเรา$jลงใน$lอาร์เรย์ของเราเพื่อใช้ในครั้งต่อไปเนื่องจากเราได้พิจารณาคุณค่าเหล่านั้นทั้งหมดแล้ว

ในที่สุดเราก็|?{$_-ne$n}จะดึงสิ่งที่ไม่ใช่องค์ประกอบอินพุตออกมา พวกมันทั้งหมดถูกทิ้งไว้บนไปป์ไลน์และเอาท์พุทก็เป็นนัย

ตัวอย่าง

PS C:\Tools\Scripts\golfing> 2,4,8,15,16,23,42,117,126,204|%{"$_ --> "+(.\prime-factors-buddies $_)}
2 --> 
4 --> 
8 --> 
15 --> 53
16 --> 
23 --> 6
42 --> 74 146 161
117 --> 279 939 993 3313 3331
126 --> 222 438 674 746 1466 483 851 1679 1631
204 --> 782 2921 3266 6233 3791 15833 2951 7037 364 868 8561 15491 22547 852 762 1626 692 548 1268 2654 3446 2474 5462 4742 5426 4274 14426 6542 6434 14642

นั่นคือเงินมากที่สุดที่ฉันเคยเห็น!
ทำให้เสียชีวิต

1
@ สรุปว่ามีเพียง 64 จาก 450 ซึ่งน่าแปลกใจนิดหน่อยในระดับต่ำ - ฉลาด (14.22%) สำหรับคำตอบ PowerShell
AdmBorkBork

8

CJam , 26 23 ไบต์

{_mfs$:XW%i){mfs$X=},^}

ลองออนไลน์

คำอธิบาย

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

_mf    e# Duplicate input N and get a list of its prime factors.
s$     e# Convert the list to a (flattened) string and sort it.
:X     e# Store this in X for later.
W%     e# Reverse it. This is now a string repesentation of the largest 
       e# possible output M.
i)     e# Convert to integer and increment.
{      e# Get a list of all integers i in [0 1 ... M] for which the following
       e# block gives a truthy result.
  mf   e#   Get list of prime factors of i.
  s$   e#   Get a sorted list of the digits appearing in the factorisation.
  X=   e#   Check for equality with X.
},
^      e# Symmetric set difference: removes N from the output list.

6

05AB1E , 17 ไบต์

รหัส:

ÒJ{©RƒNÒJ{®QN¹Ê*–

คำอธิบาย:

Ò                  # Get the factorization with duplicates, e.g. [3, 3, 13]
 J                 # Join the array, e.g. 3313
  {©               # Sort and store in ©, e.g. 1333
    R              # Reverse the number, e.g. 3331. This is the upperbound for the range
     ƒ             # For N in range(0, a + 1), do...
      NÒ           # Push the factorization with duplicates for N
        J          # Join the array
         {         # Sort the string
          ®Q       # Check if equal to the string saved in ©
            N¹Ê    # Check if not equal to the input
               *   # Multiply, acts as a logical AND
                –  # If 1, print N

ใช้การเข้ารหัสCP-1252 ลองออนไลน์!


4

Pyth, 17

LSjkPb-fqyTyQSs_y

ชุดทดสอบชุดทดสอบ

ใช้การสังเกตเช่นเดียวกับจากโพสต์ของ Martinมาร์ตินโพสต์

การขยายตัว:

LSjkPb        ##  Define a function y(b) to get the sorted string of digits
              ##  of the prime factors of b
    Pb        ##  prime factors
  jk          ##  join to a string with no separator
 S            ##  Sort

-fqyTyQSs_yQQ ##  Auto-fill variables
         _yQ  ##  get reversed value of y(input)
       Ss     ##  convert that string to a list [1 ... y(input)]
 fqyTyQ       ##  keep numbers T from the list that satisfy y(T)==y(input)
-           Q ##  remove the input from the result

3

JavaScript (ES6), 163 158 ไบต์

แก้ไข : มีการชี้แจงว่านายกเช่น 23 ควรส่งคืน [6] แทนที่จะเป็นชุดผลลัพธ์ที่ว่างเปล่า บันทึก 5 ไบต์โดยการลบกฎที่ไม่มีประโยชน์ในตอนนี้นั่นคือ - ตามวัตถุประสงค์ - ป้องกันไม่ให้เกิดเหตุการณ์เช่นนั้น

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

let f =

n=>[...Array(+(l=(p=n=>{for(i=2,m=n,s='';i<=m;n%i?i++:(s+=i,n/=i));return s.split``.sort().reverse().join``})(n))+1)].map((_,i)=>i).filter(i=>i&&i-n&&p(i)==l)

console.log(JSON.stringify(f(2)));
console.log(JSON.stringify(f(4)));
console.log(JSON.stringify(f(8)));
console.log(JSON.stringify(f(15)));
console.log(JSON.stringify(f(16)));
console.log(JSON.stringify(f(23)));
console.log(JSON.stringify(f(42)));
console.log(JSON.stringify(f(126)));
//console.log(JSON.stringify(f(204)));


1

PHP 486 ไบต์

อาจสั้นลงด้วยอัลกอริธึมที่หนังสือไม่ทำ
(แต่ฉันชอบนับไบต์ปัจจุบัน)

function p($n){for($i=1;$i++<$n;)if($n%$i<1&&($n-$i?p($i)==$i:!$r))for($x=$n;$x%$i<1;$x/=$i)$r.=$i;return $r;}function e($s){if(!$n=strlen($s))yield$s;else foreach(e(substr($s,1))as$p)for($i=$n;$i--;)yield substr($p,0,$i).$s[0].substr($p,$i);}foreach(e(p($n=$argv[1]))as$p)for($m=1<<strlen($p)-1;$m--;){$q="";foreach(str_split($p)as$i=>$c)$q.=$c.($m>>$i&1?"*":"");foreach(split("\*",$q)as$x)if(0===strpos($x,48)|p($x)!=$x)continue 2;eval("\$r[$q]=$q;");}unset($r[$n]);echo join(",",$r);

ทำให้พังถล่ม

// find and concatenate prime factors
function p($n)
{
    for($i=1;$i++<$n;)  // loop $i from 2 to $n
        if($n%$i<1      // if $n/$i has no remainder
            &&($n-$i    // and ...
                ?p($i)==$i  // $n!=$i: $i is a prime
                :!$r        // $n==$i: result so far is empty ($n is prime)
            )
        )
            for($x=$n;      // set $x to $n
                $x%$i<1;    // while $x/$i has no remainder
                $x/=$i)     // 2. divide $x by $i
                $r.=$i;     // 1. append $i to result
    return $r;
}

// create all permutations of digits
function e($s)
{
    if(!$n=strlen($s))yield$s;else  // if $s is empty, yield it, else:
    foreach(e(substr($s,1))as$p)    // for all permutations of the number w/o first digit
        for($i=$n;$i--;)            // run $i through all positions around the other digits
            // insert removed digit at that position and yield
            yield substr($p,0,$i).$s[0].substr($p,$i);
}

// for each permutation
foreach(e(p($n=$argv[1]))as$p)
    // create all products from these digits: binary loop through between the digits
    for($m=1<<strlen($p)-1;$m--;)
    {
        // and insert "*" for set bits
        $q="";
        foreach(str_split($p)as$i=>$c)$q.=$c.($m>>$i&1?"*":"");
        // test all numbers in the expression
        foreach(split("\*",$q)as$x)
            if(
                0===strpos($x,48)   // if number has a leading zero
                |p($x)!=$x          // or is not prime
            )continue 2; // try next $m
        // evaluate expression and add to results (use key to avoid array_unique)
        eval("\$r[$q]=$q;");
    }

// remove input from results
unset($r[$n]);

// output
#sort($r);
echo join(",",$r);

1

ที่จริงแล้ว 27 ไบต์

สิ่งนี้ใช้อัลกอริทึมแบบเดียวกับที่Martin , Adnan , FryAmTheEggmanและDennisใช้อยู่ ยินดีต้อนรับคำแนะนำการเล่นกอล์ฟ ลองออนไลน์!

`w"i$n"£MΣSR≈`╗╜ƒ;╝R`╜ƒ╛=`░

Ungolfing

          Implicit input n.
`...`╗    Define a function and store it in register 0. Call the function f(x).
  w         Get the prime factorization of x.
  "..."£M   Begin another function and map over the [prime, exponent] lists of w.
    i         Flatten the list. Stack: prime, exponent.
    $n        Push str(prime) to the stack, exponent times.
               The purpose of this function is to get w's prime factors to multiplicity.
  Σ         sum() the result of the map.
             On a list of strings, this has the same effect as "".join()
  SR≈       Sort that string, reverse it and convert to int.
╜ƒ        Now push the function stored in register 0 and call it immediately.
           This gives the upper bound for any possible prime factor buddy.
;╝        Duplicate this upper bound and save a copy to register 1.
R         Push the range [0..u]
`...`░    Filter the range for values where the following function returns a truthy.
           Variable k.
  ╜ƒ        Push the function in register 0 and call it on k.
  ╛=        Check if f(k) == f(n).
          Implicit return every value that is a prime factor buddy with n, including n.

1

Powershell, 147 ไบต์ (เวอร์ชั่น CodeGolf)

param($n)filter d{-join($(for($i=2;$_-ge$i*$i){if($_%$i){$i++}else{"$i"
$_/=$i}}if($_-1){"$_"})|% t*y|sort -d)}2..($s=$n|d)|?{$_-$n-and$s-eq($_|d)}

หมายเหตุ: สคริปต์แก้กรณีทดสอบล่าสุดน้อยกว่า 3 นาทีในสมุดบันทึกท้องถิ่นของฉัน ดูโซลูชัน "ประสิทธิภาพ" ด้านล่าง

สคริปต์ทดสอบที่ตีกอล์ฟน้อยกว่า:

$g = {

param($n)
filter d{                       # in the filter, Powershell automatically declares the parameter as $_
    -join($(                    # this function returns a string with all digits of all prime divisors in descending order
        for($i=2;$_-ge$i*$i){   # find all prime divisors
            if($_%$i){
                $i++
            }else{
                "$i"            # push a divisor to a pipe as a string
                $_/=$i
            }
        }
        if($_-1){
            "$_"                # push a last divisor to pipe if it is not 1
        }
    )|% t*y|sort -d)            # t*y is a shortcut to toCharArray method. It's very slow.
}
2..($s=$n|d)|?{                 # for each number from 2 to number with all digits of all prime divisors in descending order
    $_-$n-and$s-eq($_|d)        # leave only those who have the 'all digits of all prime divisors in descending order' are the same
}

}

@(
    ,(2   ,'')
    ,(4   ,'')
    ,(6   ,23)
    ,(8   ,'')
    ,(15  ,53)
    ,(16  ,'')
    ,(23  ,6)
    ,(42  ,74, 146, 161)
    ,(107 ,701)
    ,(117 ,279, 939, 993, 3313, 3331)
    ,(126 ,222, 438, 483, 674, 746, 851, 1466, 1631, 1679)
    ,(204 ,364,548,692,762,782,852,868,1268,1626,2474,2654,2921,2951,3266,3446,3791,4274,4742,5426,5462,6233,6434,6542,7037,8561,14426,14642,15491,15833,22547)
) | % {
    $n,$expected = $_

    $sw = Measure-Command {
        $result = &$g $n
    }

    $equals=$false-notin(($result|%{$_-in$expected})+($expected|?{$_-is[int]}|%{$_-in$result}))
    "$sw : $equals : $n ---> $result"
}

เอาท์พุท:

00:00:00.0346911 : True : 2 --->
00:00:00.0662627 : True : 4 --->
00:00:00.1164648 : True : 6 ---> 23
00:00:00.6376735 : True : 8 --->
00:00:00.1591527 : True : 15 ---> 53
00:00:03.8886378 : True : 16 --->
00:00:00.0441986 : True : 23 ---> 6
00:00:01.1316642 : True : 42 ---> 74 146 161
00:00:01.0393848 : True : 107 ---> 701
00:00:05.2977238 : True : 117 ---> 279 939 993 3313 3331
00:00:12.1244363 : True : 126 ---> 222 438 483 674 746 851 1466 1631 1679
00:02:50.1292786 : True : 204 ---> 364 548 692 762 782 852 868 1268 1626 2474 2654 2921 2951 3266 3446 3791 4274 4742 5426 5462 6233 6434 6542 7037 8561 14426 14642 15491 15833 22547

Powershell, 215 ไบต์ (รุ่น "ประสิทธิภาพ")

param($n)$p=@{}
filter d{$k=$_*($_-le3e3)
($p.$k=-join($(for($i=2;!$p.$_-and$_-ge$i*$i){if($_%$i){$i++}else{"$i"
$_/=$i}}if($_-1){($p.$_,"$_")[!$p.$_]})-split'(.)'-ne''|sort -d))}2..($s=$n|d)|?{$_-$n-and$s-eq($_|d)}

หมายเหตุ: ฉันเชื่อว่าข้อกำหนดด้านประสิทธิภาพมีความขัดแย้งกับหลักการของ GodeGolf แต่เนื่องจากมีกฎYour program should solve any of the test cases below in less than a minuteฉันได้ทำการเปลี่ยนแปลงสองประการเพื่อให้เป็นไปตามกฎ:

  • -split'(.)'-ne''แทนรหัสสั้น|% t*y;
  • hashtable สำหรับ cashing สตริง

การเปลี่ยนแปลงแต่ละครั้งจะลดเวลาการประเมินครึ่งหนึ่ง โปรดอย่าคิดว่าฉันได้ใช้คุณสมบัติทั้งหมดเพื่อปรับปรุงประสิทธิภาพ มีเพียงเพียงพอที่จะสนองกฎ

สคริปต์ทดสอบที่ตีกอล์ฟน้อยกว่า:

$g = {

param($n)
$p=@{}                          # hashtable for 'all digits of all prime divisors in descending order'
filter d{                       # this function returns a string with all digits of all prime divisors in descending order
    $k=$_*($_-le3e3)            # hashtable key: a large hashtable is not effective, therefore a key for numbers great then 3000 is 0
                                # and string '-le3e3' funny
    ($p.$k=-join($(             # store the value to hashtable
        for($i=2;!$p.$_-and$_-ge$i*$i){
            if($_%$i){$i++}else{"$i";$_/=$i}
        }
        if($_-1){
            ($p.$_,"$_")[!$p.$_] # get a string with 'all digits of all prime divisors in descending order' from hashtable if it found
        }
    )-split'(.)'-ne''|sort -d)) # split each digit. The "-split'(.)-ne''" code is faster then '|% t*y' but longer.
}
2..($s=$n|d)|?{                 # for each number from 2 to number with all digits of all prime divisors in descending order
    $_-$n-and$s-eq($_|d)        # leave only those who have the 'all digits of all prime divisors in descending order' are the same
}

}

@(
    ,(2   ,'')
    ,(4   ,'')
    ,(6   ,23)
    ,(8   ,'')
    ,(15  ,53)
    ,(16  ,'')
    ,(23  ,6)
    ,(42  ,74, 146, 161)
    ,(107 ,701)
    ,(117 ,279, 939, 993, 3313, 3331)
    ,(126 ,222, 438, 483, 674, 746, 851, 1466, 1631, 1679)
    ,(204 ,364,548,692,762,782,852,868,1268,1626,2474,2654,2921,2951,3266,3446,3791,4274,4742,5426,5462,6233,6434,6542,7037,8561,14426,14642,15491,15833,22547)
) | % {
    $n,$expected = $_

    $sw = Measure-Command {
        $result = &$g $n
    }

    $equals=$false-notin(($result|%{$_-in$expected})+($expected|?{$_-is[int]}|%{$_-in$result}))
    "$sw : $equals : $n ---> $result"
}

เอาท์พุท:

00:00:00.0183237 : True : 2 --->
00:00:00.0058198 : True : 4 --->
00:00:00.0181185 : True : 6 ---> 23
00:00:00.4389282 : True : 8 --->
00:00:00.0132624 : True : 15 ---> 53
00:00:04.4952714 : True : 16 --->
00:00:00.0128230 : True : 23 ---> 6
00:00:01.4112716 : True : 42 ---> 74 146 161
00:00:01.3676701 : True : 107 ---> 701
00:00:07.1192912 : True : 117 ---> 279 939 993 3313 3331
00:00:07.6578543 : True : 126 ---> 222 438 483 674 746 851 1466 1631 1679
00:00:50.5501853 : True : 204 ---> 364 548 692 762 782 852 868 1268 1626 2474 2654 2921 2951 3266 3446 3791 4274 4742 5426 5462 6233 6434 6542 7037 8561 14426 14642 15491 15833 22547

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.