Yếu tố bạn thân


21

Cho một số nguyên N > 1, xuất ra tất cả các số khác phân tách số nguyên tố có cùng chữ số với phân số nguyên tố của N.

Ví dụ, nếu N = 117, thì đầu ra phải [279, 939, 993, 3313, 3331], bởi vì

117 = 3 × 3 × 13

Vì vậy, các chữ số sẵn có 1, 3, 33và chúng tôi có

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

Đó chỉ là những số có thể khác, bởi vì sự kết hợp khác của các chữ số này mang lại số nguyên không nguyên tố, không thể là kết quả của thừa số nguyên tố.

Nếu Nlà bất kỳ 117, 279, 939, 993, 3313hoặc3331 , sau đó đầu ra sẽ chứa năm số khác: họ là thừa số nguyên tố bạn bè.

Bạn không thể sử dụng các số 0 đứng đầu để lấy số nguyên tố, ví dụ: N = 107bạn thân duy nhất của nó là 701(017 không được xem xét).

Đầu vào và đầu ra

  • Bạn bè đầu vào và đầu ra phải được lấy và trả lại trong cơ sở thập phân.

  • Nsẽ luôn luôn nghiêm túc hơn 1.

  • Đầu ra có thể được định dạng khá tự do, miễn là nó chỉ chứa các phần tử cú pháp và dấu tách / danh sách.

  • Thứ tự của đầu ra là không quan trọng.

  • Bạn có thể lấy đầu vào thông qua STDIN, như là một đối số chức năng hoặc bất cứ điều gì tương tự.

  • Bạn có thể in đầu ra STDOUT, trả lại từ một chức năng hoặc bất cứ thứ gì tương tự.

Các trường hợp thử nghiệm

Chương trình của bạn sẽ giải quyết bất kỳ trường hợp thử nghiệm nào dưới đây trong vòng chưa đầy một phút .

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]

Chấm điểm

Đây là , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng.

Câu trả lời:


4

Thạch , 14 byte

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

Thời gian thực hiện có thể giảm một nửa DFthay vì V, nhưng nó vẫn hoàn thành các trường hợp thử nghiệm kết hợp trong vòng dưới ba mươi giây.

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

Æ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.

Tôi nghĩ rằng nó Ç€=$sẽ nhanh hơn một chút so với Ç€=Çthời gian hạn chế.
Erik the Outgolfer 18/07/17

Cảm ơn, nhưng đối với đầu vào 117 , sự cải thiện của bạn có nghĩa là liên kết của người trợ giúp sẽ được gọi là 3331 lần thay vì 3332 lần, vì vậy việc tăng tốc độ là không thể đo lường được. Dù sao, TIO mới hơn (nhanh hơn) thậm chí không cần 20 giây cho các trường hợp thử nghiệm kết hợp.
Dennis

16

PowerShell v3 +, 450 byte

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}

Cuối cùng!

PowerShell không có bất kỳ công cụ tích hợp nào để kiểm tra tính nguyên thủy, hệ số hóa hoặc hoán vị, do đó, điều này hoàn toàn được thực hiện bằng tay. Tôi đã làm việc thông qua một loạt các thủ thuật tối ưu hóa để thử và giảm độ phức tạp thời gian xuống một thứ phù hợp với các hạn chế thách thức và tôi rất vui khi nói rằng cuối cùng tôi đã thành công -

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

Giải trình

Có rất nhiều thứ đang diễn ra ở đây, vì vậy tôi sẽ cố gắng phá vỡ nó.

Dòng đầu tiên nhận đầu vào $nvà định nghĩa một function, f. Hàm này sử dụng phân chia thử nghiệm tích lũy để đưa ra danh sách các yếu tố chính. Nó khá nhanh đối với các đầu vào nhỏ, nhưng rõ ràng sẽ sa lầy nếu đầu vào lớn. Rất may tất cả các trường hợp thử nghiệm là nhỏ, vì vậy điều này là đủ.

Dòng tiếp theo được các fdiễn viên của $n, -splitlà chúng trên tất cả các chữ số bỏ qua bất kỳ kết quả rỗng (điều này là cần thiết do cách PowerShell không khớp regex và làm thế nào nó di chuyển con trỏ qua các đầu vào và là kinda khó chịu cho chơi golf mục đích), sau đó sortlà các kết quả theo thứ tự tăng dần. Chúng tôi lưu trữ mảng chữ số đó vào $xvà sử dụng đó làm đầu vào cho |?{...}bộ lọc để chỉ lấy ra những chữ số chính. Những chữ số nguyên tố được lưu trữ vào$y để sử dụng sau.

Sau đó chúng tôi chia $xthành hai thành phần. Chữ số đầu tiên (nghĩa là nhỏ nhất) được lưu trữ $a, trong khi phần còn lại được truyền vào $b. Nếu $xchỉ có một chữ số, thì $bsẽ trống / null. Sau đó chúng ta cần phải phân vai lại$a thành một mảng, vì vậy chúng tôi sử dụng toán tử dấu phẩy nhanh chóng để làm như vậy.

Tiếp theo, chúng ta cần xây dựng tất cả các hoán vị có thể có của các chữ số. Điều này là cần thiết để kiểm tra phân chia của chúng tôi sau đó bỏ qua một loạt các số và làm cho mọi thứ nhanh hơn tổng thể.

Chừng nào còn yếu tố còn lại $b, chúng tôi bóc chữ số đầu tiên vào $zvà bỏ phần còn lại vào $b. Sau đó, chúng ta cần tích lũy vào $akết quả của một số chuỗi cắt và thái hạt lựu. Chúng tôi $a+$ynhư mảng nối, và cho mỗi phần tử chúng ta xây dựng một chuỗi mới $c, sau đó lặp qua $c's .lengthvà chèn $zvào tất cả các vị trí, bao gồm thêm vào trước $z$cvà phụ thêm $c$z, sau đó selectchỉ ing các -uyếu tố nique. Đó lại là một mảng được nối với $avà được lưu trữ lại $a. Vâng, điều này sẽ kết thúc khi có những điều ngớ ngẩn xảy ra, như bạn có thể nhận được 3333cho đầu vào117, đó không thực sự là một hoán vị, nhưng điều này ngắn hơn nhiều so với việc cố gắng lọc chúng ra một cách rõ ràng, đảm bảo rằng chúng ta có được mọi hoán vị và chỉ chậm hơn một chút.

Vì vậy, bây giờ $acó một mảng của tất cả các hoán vị có thể (và sau đó là một số) các chữ số của yếu tố. Chúng ta cần đặt lại thành $xgiới hạn trên của các kết quả có thể bằng cách nhập |sortcác chữ số theo -desthứ tự giới hạn và -joinđưa chúng trở lại với nhau. Rõ ràng, không có giá trị đầu ra có thể lớn hơn con số này.

Chúng tôi đặt mảng trình trợ giúp của $lmình là một mảng các giá trị mà chúng ta đã thấy trước đây. Tiếp theo, chúng tôi rút ra mọi giá trị từ $a(nghĩa là những hoán vị đó) là số nguyên tố và nhập một vòng lặp là khoảng thời gian lớn nhất của toàn bộ chương trình ...

Mỗi lần lặp lại, chúng tôi lặp từ 0giới hạn trên của chúng tôi $x, tăng dần theo yếu tố hiện tại $j. Miễn là $igiá trị chúng tôi xem xét không phải là bội số của giá trị trước đó (đó là 0-notin($l|%{$i%$_})phần), đó là một ứng cử viên tiềm năng cho đầu ra. Nếu chúng ta lấy các fdiễn viên của $i, sorthọ, và họ -equal $x, sau đó thêm giá trị cho các đường ống dẫn. Vào cuối vòng lặp, chúng tôi thêm phần tử hiện tại $jvào $lmảng của chúng tôi để sử dụng vào lần tới, vì chúng tôi đã xem xét tất cả các giá trị đó.

Cuối cùng, chúng tôi đã giải |?{$_-ne$n}quyết để rút ra những thứ không phải là yếu tố đầu vào. Tất cả đều còn lại trên đường ống và đầu ra là ẩn.

Ví dụ

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

Đó là số tiền nhiều nhất tôi từng thấy!
Gây tử vong vào

1
@Firthize Đó chỉ là 64 trên 450, điều đáng ngạc nhiên là một chút về tỷ lệ phần trăm thấp (14,22%) cho các câu trả lời của PowerShell.
admBorkBork

8

CJam , 26 23 byte

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

Dùng thử trực tuyến

Giải trình

Ghép hai số luôn cho kết quả lớn hơn so với nhân chúng. Vì vậy, số lớn nhất chúng ta có thể cần xem xét là số lớn nhất chúng ta có thể hình thành từ các chữ số của hệ số nguyên tố đầu vào, chỉ là tất cả các chữ số được sắp xếp theo thứ tự giảm dần. Đối với các số đã cho, giới hạn trên này dễ dàng đủ nhỏ để chúng ta có thể kiểm tra toàn diện mọi số trong phạm vi xem đó có phải là bạn thân của yếu tố chính hay không:

_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 byte

Mã số:

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

Giải trình:

Ò                  # 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

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến!


4

Bình thường, 17

LSjkPb-fqyTyQSs_y

Bộ thử nghiệm .

Sử dụng quan sát tương tự như từ bài viết của Martin .

Sự bành trướng:

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 byte

Chỉnh sửa : Đã làm rõ rằng một số nguyên tố như 23 sẽ trả về [6] thay vì một tập kết quả trống. Đã lưu 5 byte bằng cách loại bỏ một quy tắc vô dụng bây giờ - về mục đích - ngăn chặn điều đó xảy ra.

Trường hợp thử nghiệm cuối cùng được nhận xét để đoạn mã này chạy đủ nhanh, mặc dù nó cũng sẽ hoàn thành trong chưa đầy một phút.

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 byte

có lẽ có thể ngắn hơn với một thuật toán mà cuốn sách không như vậy bởi cuốn sách.
(nhưng tôi thích số byte hiện tại)

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);

phá vỡ

// 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

Trên thực tế, 27 byte

Điều này sử dụng cùng một thuật toán mà Martin , Adnan , FryAmTheEggmanDennis đã sử dụng. Gợi ý chơi golf chào mừng. Hãy thử trực tuyến!

`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 byte (phiên bản 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)}

Lưu ý: Kịch bản giải quyết các trường hợp kiểm tra cuối cùng ít hơn 3 phút trên sổ ghi chép cục bộ của tôi. Xem giải pháp "hiệu suất" dưới đây.

Kịch bản kiểm tra ít chơi gôn hơn:

$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"
}

Đầu ra:

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 byte (phiên bản "Hiệu suất")

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)}

Lưu ý: Tôi tin rằng các yêu cầu về hiệu suất mâu thuẫn với nguyên tắc GodeGolf. Nhưng vì đã có một quy tắcYour program should solve any of the test cases below in less than a minute , tôi đã thực hiện hai thay đổi để đáp ứng quy tắc:

  • -split'(.)'-ne''thay vào đó là mã ngắn |% t*y;
  • một hashtable cho chuỗi tiền mặt.

Mỗi thay đổi làm giảm thời gian đánh giá một nửa. Xin đừng nghĩ rằng tôi đã sử dụng tất cả các tính năng để cải thiện hiệu suất. Chỉ cần những điều đó là đủ để đáp ứng các quy tắc.

Kịch bản kiểm tra ít chơi gôn hơn:

$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"
}

Đầu ra:

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

Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.