Geben Sie bei einer Ganzzahl N > 1alle anderen Zahlen aus, deren Primzerlegungen die gleichen Ziffern haben wie die Primzerlegung von N.

Wenn zum Beispiel, N = 117dann muss die Ausgabe [279, 939, 993, 3313, 3331], weil sein

117 = 3 × 3 × 13

Daher sind die zur Verfügung stehenden Ziffern 1, 3, 3und , 3und wir haben

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

Dies sind die einzig möglichen anderen Zahlen, da eine andere Kombination dieser Ziffern Nicht-Primzahlen ergibt, die nicht das Ergebnis einer Primfaktorisierung sein können.

Wenn Nirgendeine von 117, 279, 939, 993, 3313oder 3331, dann wird der Ausgang der fünf anderen Zahlen enthalten: sie sind Primfaktoren Kumpels.

Sie können keine führenden Nullen verwenden, um Primzahlen zu erhalten, z. B. N = 107ist der einzige Freund 701( 017wird nicht berücksichtigt).

Ein- und Ausgänge

• Die Eingabe- und Ausgabe-Buddies müssen in der Dezimalbasis genommen und zurückgegeben werden.

• Nwird immer strikt größer sein als 1.

• Die Ausgabe kann ziemlich frei formatiert werden, solange sie nur die syntaktischen Elemente Buddies und Separatoren / Listen enthält.

• Die Reihenfolge der Ausgabe ist unwichtig.

• Sie können die Eingabe STDINals Funktionsargument oder ähnliches durchgehen .

• Sie können die Ausgabe an drucken STDOUT, von einer Funktion zurückgeben oder etwas Ähnliches.

Testfälle

Ihr Programm sollte einen der folgenden Testfälle in weniger als einer Minute lösen .

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]

Wertung

Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.

Jelly , 14 Bytes

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

Die Ausführungszeit könnte stattdessen halbiert DFwerden V, die kombinierten Testfälle sind jedoch in weniger als 30 Sekunden abgeschlossen.

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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

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}

Endlich!

PowerShell verfügt über keine integrierten Funktionen für die Prüfung, Faktorisierung oder Permutation von Primzahlen. Daher wird diese Funktion vollständig von Hand ausgeführt. Ich habe eine Reihe von Optimierungs-Tricks durchgearbeitet, um die Zeitkomplexität auf etwas zu reduzieren, das in die Herausforderungseinschränkungen passt, und ich bin froh zu sagen, dass es mir endlich gelungen ist -

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

Erläuterung

Hier ist viel los, also werde ich versuchen, es zu zerschlagen.

Die erste Zeile nimmt die Eingabe $nund definiert eine function, f. Diese Funktion verwendet die akkumulative Versuchsaufteilung, um eine Liste der Primfaktoren zu erstellen. Es ist ziemlich schnell für kleine Eingaben, aber es bleibt offensichtlich hängen, wenn die Eingabe groß ist. Zum Glück sind alle Testfälle klein, das ist also ausreichend.

Die nächste Zeile wird die fAkteure $n, -splits sie auf jede Ziffer alle leeren Ergebnisse zu ignorieren (dies aufgrund benötigt wird , wie Powershell funktioniert Regex Matching und wie es sich bewegt den Zeiger über die Eingabe und ist ein bisschen ärgerlich für Golfzwecke), dann sorts die Ergebnisse in aufsteigender Reihenfolge. Wir speichern dieses Array von Ziffern in $xund verwenden es als Eingabe für einen |?{...}Filter, um nur diejenigen herauszufiltern, die selbst Primzahlen sind. Diese Primzahlen werden $yzur späteren Verwendung gespeichert .

Wir haben uns dann $xin zwei Komponenten aufgeteilt. Die erste (dh kleinste) Ziffer wird in gespeichert $a, während der Rest in übergeben wird $b. Wenn $xnur eine Ziffer vorhanden ist, ist $bdiese leer / null. Wir müssen dann $aals Array umwandeln, also verwenden wir den Komma-Operator schnell, um dies zu tun.

Als nächstes müssen wir alle möglichen Permutationen der Ziffern konstruieren. Dies ist notwendig, damit unsere Divisionstests später eine Reihe von Zahlen überspringen und die Dinge insgesamt schneller machen.

Solange noch ein Element vorhanden ist $b, ziehen wir die erste Ziffer in ab $zund lassen die verbleibenden in $b. Dann müssen wir uns zu $adem Ergebnis des Schneidens und Zerteilens von Schnüren ansammeln . Wir nehmen $a+$yals Array Verkettung, und für jedes Element wir eine neue Zeichenkette konstruieren $c, dann eine Schleife durch $c‚s .lengthund Insert $zin jede Position, einschließlich Voranstellen $z$cund Anhängen $c$z, dann selecting nur die -unique Elemente. Das ist wieder Array-verkettet mit $aund wieder in gespeichert $a. Ja, dies führt dazu, dass doofe Dinge passieren, wie Sie sie 3333zur Eingabe bekommen können117, was eigentlich keine Permutation ist, aber viel kürzer als der Versuch, sie explizit herauszufiltern, stellt sicher, dass wir jede Permutation erhalten, und ist nur geringfügig langsamer.

Also, hat jetzt $aein Array aller möglichen (und dann einige) Permutationen der Ziffern des Faktors. Wir müssen neu einstellen $x, um unsere Obergrenze für mögliche Ergebnisse zu erreichen, indem wir |sortdie Ziffern in -desaufsteigender Reihenfolge und -joinwieder zusammensetzen. Offensichtlich kann kein Ausgabewert größer als diese Zahl sein.

Wir setzen unser Helfer-Array $lauf ein Array von Werten, die wir zuvor gesehen haben. Als nächstes ziehen wir jeden Wert aus $a(dh den Permutationen), die Primzahlen sind, und treten in eine Schleife ein, die die größte Zeitsenke des gesamten Programms darstellt ...

Bei jeder Iteration durchlaufen wir eine Schleife 0bis zu unserer oberen Grenze $xund erhöhen sie um das aktuelle Element $j. Solange der $iWert, den wir betrachten, kein Vielfaches eines vorherigen Wertes ist (das ist der 0-notin($l|%{$i%$_})Abschnitt), ist er ein potenzieller Kandidat für die Ausgabe. Wenn wir die fAkteure von $i, von sortund nach -eqnehmen $x, dann addieren Sie den Wert zur Rohrleitung. Am Ende der Schleife fügen wir unser aktuelles Element zur nächsten Verwendung $jin unser $lArray ein, da wir alle diese Werte bereits berücksichtigt haben.

Schließlich werden wir |?{$_-ne$n}diejenigen herausziehen, die nicht das Eingabeelement sind. Sie verbleiben alle in der Pipeline und die Ausgabe ist implizit.

Beispiele

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

CJam , 26 23 Bytes

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

Probieren Sie es online aus

Erläuterung

Die Verkettung zweier Zahlen ergibt immer ein größeres Ergebnis als die Multiplikation. Die größte Zahl, die wir möglicherweise berücksichtigen müssen, ist die größte Zahl, die wir aus den Ziffern der Primfaktorisierung der Eingabe bilden können. Dabei handelt es sich nur um alle Ziffern, die in absteigender Reihenfolge sortiert sind. Für die angegebenen Zahlen ist diese Obergrenze leicht so klein, dass wir jede Zahl im Bereich gründlich daraufhin überprüfen können, ob es sich um einen Primfaktor handelt:

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

05AB1E , 17 Bytes

Code:

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

Erläuterung:

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

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Pyth, 17

LSjkPb-fqyTyQSs_y

Testsuite .

Verwendet die gleiche Beobachtung wie von Martins Posten .

Erweiterung:

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

JavaScript (ES6), 163 158 Bytes

Bearbeiten : Es wurde klargestellt, dass eine Primzahl wie 23 eher eine leere Ergebnismenge zurückgeben sollte [6]. 5 Bytes gespart, indem eine jetzt unbrauchbare Regel entfernt wurde, die dies absichtlich verhinderte.

Der letzte Testfall ist so kommentiert, dass dieses Snippet schnell genug ausgeführt wird, obwohl es auch in weniger als einer Minute abgeschlossen sein sollte.

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

PHP 486 Bytes

könnte mit einem Algorithmus, der nicht so aussieht, wahrscheinlich kürzer sein.
(aber ich mag die aktuelle Byteanzahl)

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

Nervenzusammenbruch

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

Eigentlich 27 Bytes

Dabei wird derselbe Algorithmus verwendet, den Martin , Adnan , FryAmTheEggman und Dennis verwendet haben. Golfvorschläge sind willkommen. Probieren Sie es online!

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

Powershell, 147 Bytes (CodeGolf-Version)

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

Hinweis: Das Skript löst die letzten Testfälle in weniger als 3 Minuten auf meinem lokalen Notebook. Siehe unten stehende Lösung "Leistung".

Weniger Golf-Testskript:

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

Ausgabe:

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 Bytes ("Performance" -Version)

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

Hinweis: Ich glaube, dass die Leistungsanforderungen im Widerspruch zum GodeGolf-Prinzip stehen. Da es jedoch eine Regel gab Your program should solve any of the test cases below in less than a minute, habe ich zwei Änderungen vorgenommen, um die Regel zu erfüllen:

• -split'(.)'-ne''stattdessen der Funktionscode |% t*y;
• eine Hashtabelle zum Einlösen von Strings.

Jede Änderung reduziert die Auswertungszeit um die Hälfte. Denken Sie bitte nicht, dass ich alle Funktionen genutzt habe, um die Leistung zu verbessern. Nur das genügte, um die Regel zu erfüllen.

Weniger Golf-Testskript:

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

Ausgabe:

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

Japt, 18 Bytes

k –
Ôn õ f@¥Xk ¬ñ

Versuch es