In einer kürzlichen Folge von QI wurden die ersten 5 Vielfachen von 142857 als Anagramme der ursprünglichen Zahl beschrieben. Natürlich weiß jeder, der diese Zahl nicht nur kennt, dass diese Zahlen tatsächlich zyklisch sind, nicht nur Anagramme. Aber das brachte mich zum Nachdenken.

Bitte schreiben Sie ein Programm oder eine Funktion, die alle sechs- oder wenigerstelligen Zahlen ausgibt, deren richtiger Faktor ein Anagramm für sich ist. Die Liste sollte mit folgenden Zahlen beginnen:

3105    (divisible by 1035)
7128    (divisible by 1782)
7425    (divisible by 2475)
8316    (divisible by 1386)
8712    (divisible by 2178)
9513    (divisible by 1359)
9801    (divisible by 1089)

Wenn Sie es vorziehen, können Sie Zahlen mit einem Anagramm finden, das ein geeigneter Faktor für die Zahl ist. Achten Sie jedoch darauf, führende Nullen aus Ihren Anagrammen auszuschließen.

Dies ist Codegolf, daher gewinnt der kürzeste Code in Bytes, der keine Standardlücken durchbricht.

Mathematica (REPL environment), 75 74 Bytes

Vielen Dank an ngenisis, die dies byteweise verbessert haben!

Select[Range[10!],Most@#~MemberQ~Last@#&[Sort/@IntegerDigits@Divisors@#]&]

Sort/@IntegerDigits@Divisors@#erzeugt eine sortierte Liste von Ziffern für jeden Teiler seines Arguments; Die eingegebene Zahl ist selbst ein Divisor, daher ist die sortierte Ziffernliste die letzte. Most@#~MemberQ~LastErkennt, ob die zuletzt sortierte Ziffernliste auch in der Liste vor dem letzten Element angezeigt wird. Und Select[Range[10!],...]behält nur die ganzen Zahlen bis zu 3.628.800 bei, die diesen Test bestehen (die ausgewählte Grenze, weil sie ein Byte kürzer als 10 ^{6 ist} ). Es läuft in ungefähr 5 Minuten auf meinem Computer und liefert eine Liste mit 494 Nummern, von denen die größte 3.427.191 ist. Es gibt 362 Nummern bis zu 10 ⁶ , von denen die größte 989.901 ist.

Gelee , 12 Bytes

ÆḌṢ€ċṢ
ȷ6ÇÐf

Probieren Sie es online! (verwendet fünf oder weniger Ziffern aufgrund des Zeitlimits von TIO)

Verifizierung

$ time jelly eun 'ÆḌṢ€ċṢ¶ȷ6ÇÐf'
[3105, 7128, 7425, 8316, 8712, 9513, 9801, 30105, 31050, 37125, 42741, 44172, 67128, 70416, 71208, 71253, 71280, 71328, 71928, 72108, 72441, 74142, 74250, 74628, 74925, 78912, 79128, 80712, 81816, 82755, 83160, 83181, 83916, 84510, 85725, 86712, 87120, 87132, 87192, 87912, 89154, 90321, 90801, 91152, 91203, 93513, 94041, 94143, 95130, 95193, 95613, 95832, 98010, 98091, 98901, 251748, 257148, 285174, 285714, 300105, 301050, 307125, 310284, 310500, 321705, 341172, 342711, 370521, 371142, 371250, 371628, 371925, 372411, 384102, 403515, 405135, 410256, 411372, 411723, 415368, 415380, 415638, 419076, 419580, 420741, 421056, 423711, 425016, 427113, 427410, 427491, 428571, 430515, 431379, 431568, 435105, 436158, 441072, 441720, 449172, 451035, 451305, 458112, 461538, 463158, 471852, 475281, 501624, 502416, 504216, 512208, 512820, 517428, 517482, 517725, 525771, 527175, 561024, 562104, 568971, 571428, 571482, 581124, 589761, 615384, 619584, 620379, 620568, 623079, 625128, 641088, 667128, 670416, 671208, 671280, 671328, 671928, 672108, 678912, 679128, 681072, 691872, 692037, 692307, 704016, 704136, 704160, 704196, 705213, 705321, 706416, 711342, 711423, 712008, 712080, 712503, 712530, 712800, 713208, 713280, 713328, 713748, 714285, 716283, 717948, 719208, 719253, 719280, 719328, 719928, 720108, 720441, 721068, 721080, 721308, 721602, 723411, 724113, 724410, 724491, 728244, 730812, 731892, 732108, 741042, 741285, 741420, 742284, 742500, 744822, 746280, 746928, 749142, 749250, 749628, 749925, 753081, 754188, 755271, 760212, 761082, 761238, 761904, 771525, 772551, 779148, 783111, 786912, 789120, 789132, 789192, 789312, 790416, 791208, 791280, 791328, 791928, 792108, 798912, 799128, 800712, 806712, 807120, 807132, 807192, 807912, 814752, 816816, 818160, 818916, 820512, 822744, 823716, 824472, 825174, 825714, 827550, 827658, 827955, 829467, 830412, 831117, 831600, 831762, 831810, 831831, 839160, 839181, 839916, 840510, 841023, 841104, 843102, 845100, 845910, 847422, 851148, 851220, 851742, 852471, 857142, 857250, 857628, 857925, 862512, 862758, 862947, 865728, 866712, 867120, 867132, 867192, 867912, 871200, 871320, 871332, 871425, 871920, 871932, 871992, 874125, 879120, 879132, 879192, 879912, 888216, 891054, 891540, 891594, 891723, 892755, 894510, 895725, 899154, 900801, 901152, 903021, 903210, 903231, 904041, 908010, 908091, 908901, 909321, 910203, 911043, 911358, 911520, 911736, 911952, 912030, 912093, 912303, 916083, 920241, 920376, 923076, 923580, 925113, 925614, 930321, 931176, 931203, 933513, 934143, 935130, 935193, 935613, 935832, 940410, 940491, 941430, 941493, 941652, 943137, 943173, 951300, 951588, 951930, 951993, 952380, 956130, 956193, 956613, 958032, 958320, 958332, 958392, 958632, 958716, 959832, 960741, 962037, 962307, 970137, 971028, 980100, 980910, 980991, 989010, 989091, 989901]

real    2m10.819s
user    2m10.683s
sys     0m0.192s

Wie es funktioniert

ȷ6ÇÐf   Main link. No arguments.

ȷ6      Yield 1e6 = 1,000,000.
  ÇÐf   Filter; keep numbers in [1, ..., 1e6] for which the helper link returns
        a truthy value.


ÆḌṢ€ċṢ  Helper link. Argument: n

ÆḌ      Compute all proper divisors of n.
  Ṣ€    Sort each proper divisor's digits.
     Ṣ  Sort n's digits.
   ċ    Count the occurrences of the result to the right in the result to the left.

Brachylog , 12 Bytes

ℕf{k∋p.!}?ẉ⊥

Probieren Sie es online!

Dies kann jedoch zu einer Zeitüberschreitung führen, bevor etwas gedruckt wird (und wenn dies nicht der Fall ist, wird nur 3105 gedruckt).

Erläuterung

Diese Zahlen werden auf unbestimmte Zeit gedruckt, da der Autor sagte, es sei akzeptabel, dass das Programm Zahlen mit mehr als 6 Stellen druckt.

Das ist viel zu langsam; Sie können dieses Programm verwenden (und 8300beliebig ändern N), um den Druckvorgang ab Zahlen zu starten, die strikt größer als sind N.

ℕ               Natural number: The Input is a natural number
 f              Factors: compute the factors of the Input
  {     }?      Call a predicate with the main Input as its output and the factors as Input
   k            Knife: remove the last factor(which is the Input itself)
    ∋           In: take one of those factors
     p.         Permute: the Output is a permutation of that factor
       !        Cut: ignore other possible permutations
         ?ẉ     Writeln: write the Input to STDOUT, followed by a line break
           ⊥    False: backtrack to try another value for the Input

Wie @ ais523 betonte, benötigen wir einen Schnitt, um zu vermeiden, dass eine Zahl mehrmals gedruckt wird, wenn mehrere ihrer Faktoren Permutationen davon sind.

JavaScript (ES6), 103 … 96 94 Bytes

Eine anonyme Funktion, die das Array übereinstimmender Ganzzahlen zurückgibt.

_=>[...Array(1e6).keys(F=i=>[...i+''].sort()+0)].filter(n=>n*(R=i=>F(n/i--)==F(n)||R(i)%i)(9))

Formatiert und kommentiert

_ =>                                // main function, takes no input
  [...Array(1e6).keys(              // define an array of 1,000,000 entries
    F = i => [...i + ''].sort() + 0 // define F: function used to normalize a string by
  )]                                // sorting its characters
  .filter(n =>                      // for each entry in the array:
    n * (                           // force falsy result for n = 0
      R = i =>                      // define R: recursive function used to test if
        F(n / i--) == F(n) ||       // n/i is an anagram of n, with i in [1 … 9]
        R(i) % i                    // F(n/1) == F(n) is always true, which allows to stop
    )                               // the recursion; but we need '%i' to ignore this result
    (9)                             // start recursion with i = 9
  )                                 //

Divisor-Statistik

Bei 6-stelligen Ganzzahlen wird jedes Verhältnis von 2zu 9zwischen einer übereinstimmenden Ganzzahl nund ihrem Anagramm mindestens einmal angetroffen. Aber einige von ihnen kommen nur ein paar Mal vor:

 divisor | occurrences | first occurrence
---------+-------------+---------------------
    2    |    12       | 251748 / 2 = 125874
    3    |    118      | 3105   / 3 = 1035
    4    |    120      | 7128   / 4 = 1782
    5    |    4        | 714285 / 5 = 142857
    6    |    34       | 8316   / 6 = 1386
    7    |    49       | 9513   / 7 = 1359
    8    |    2        | 911736 / 8 = 113967
    9    |    23       | 9801   / 9 = 1089

Prüfung

Der folgende Test ist auf den Bereich beschränkt, [1 ... 39999]damit die Ausführung nicht zu lange dauert.

let f =

_=>[...Array(4e4).keys(F=i=>[...i+''].sort()+0)].filter(n=>n*(R=i=>F(n/i--)==F(n)||R(i)%i)(9))

console.log(f())

Pyke, 14 Bytes

~1#`Sili-m`mS{

Probieren Sie es hier aus!

Sollte alle Zahlen wie folgt ausgeben, aber mal aus.

Testen Sie den Algorithmus hier!

Perl 6 , 59 Bytes

{grep {grep .comb.Bag===*.comb.Bag,grep $_%%*,2..^$_}

Schrecklich langsame Brute-Force-Lösung.

Es wird eine verzögerte Sequenz zurückgegeben, sodass ich die ersten Ergebnisse überprüfen konnte, aber nicht alle Ergebnisse in angemessener Zeit erreichen kann. (Soll ich es als nicht konkurrierend markieren?)

Pure Bash , 128 126 122 121 120 Bytes

for((;n<6**8;)){
c=0
for((j=++n;j;j/=10)){((c+=8**(j%10)));}
for k in ${a[c]};{((n%k))||{ echo $n;break;};}
a[c]+=\ $n
}

Probieren Sie es online!

(Dieses Programm ist relativ schnell - es hat nur 14 Minuten gedauert, bis alle 6-stelligen Nummern auf meinem MacBook durchgelaufen sind. Leider läuft TIO ab, da es eine Laufzeitbegrenzung von 1 Minute vorsieht, was nur genug Zeit ist, um durchzukommen die 5-stelligen Zahlen oder so.)

Bash + Unix-Dienstprogramme, 117 Bytes

for n in {1..999999}
{
c=$(bc<<<0`sed 's/\(.\)/+8^\1/g'<<<$n`)
for k in ${a[c]};{((n%k))||echo $n;}
a[c]+=\ $n
}|uniq

Dies ist kürzer als die reine Bash-Version, aber einiges langsamer, vermutlich zum großen Teil aufgrund der vielen Gabelungen.

05AB1E , 15 Bytes

[¼¾œJv¾Ñ¨Dyåi¾,

Erläuterung:

[               # Start of infinite loop
 ¼              # Increase counter_variable by 1
  ¾œJv          # Loop through all the permutations of counter_variable
      ¾Ñ¨Dyå    # Check if a divisor of counter_variable is a permutation of counter_variable
            i¾, # If so, print counter_variable

Probieren Sie es online! (Dies wird nicht funktionieren, es wird Zeitüberschreitung)

Japt , 23 Bytes

L³o f_ì á ¤fg mì f!vZ l

Probieren Sie es online! Beachten Sie, dass der verknüpfte Code nur bis zu 1e4 berechnet, da 1e6 bei TIO eine Zeitüberschreitung aufweist.

Python 2, 98 Bytes

s=sorted;print filter(None,[[x for i in range(x)if s(`x`)==s(`i`)and x%i<1]for x in range(10**6)])

05AB1E , 12 10 Bytes

Zeitüberschreitung bei TIO aufgrund einer Endlosschleife.
2 Bytes gespart, da wir laut OPs Kommentar mehr als 6-stellige Zahlen ausgeben konnten.

[NѨ€{N{å–

Probieren Sie es online!

Erläuterung

[            # infinite loop with iteration index N
 NÑ          # get a list of all divisors of N
   ¨         # remove N from that list
    €{       # sort each entry in the list of divisors
      N{     # sort N
        å–   # output N if N is in the list

Batch, 263 Bytes

@echo off
set e=exit/b
for /l %%n in (1,1,999999)do call:n %%n
%e%
:n
call:c %1 1 0
for /l %%f in (2,1,9)do call:c %1 %%f %c%&&echo %1&&%e%
%e%
:c
set/ar=%1%%%2,d=%1/%2,c=-%3
if %r% gtr 0 %e%1
:l
set/ac+=1^<^<d%%10*3,d/=10
if %d% gtr 0 goto l
%e%%c%

Schleppend. Wie in, dauert es über einen Tag, bis es auf meinem PC fertig ist. Erläuterung: Das cUnterprogramm teilt die ersten beiden Argumente. Wenn der Rest Null ist, berechnet er den Hash des Ergebnisses, indem er die Summe der n-ten Potenzen von 8 für jede Ziffer berechnet. Diese aus der Bash-Antwort gestohlene Hash-Funktion kollidiert nur mit Anagrammen. (Es würde für siebenstellige Zahlen funktionieren, aber ich habe nicht alle vierzehn Tage.) Das dritte Argument wird abgezogen, und die Subroutine wird mit einem wahrheitsgemäßen Ergebnis beendet, wenn dies Null ist. Die nSubroutine ruft die cSubroutine einmal auf, um den Hash zu berechnen, und acht weitere Male, um den Hash zu vergleichen. Wenn eine Kollision festgestellt wird, wird ndie Unterroutine frühzeitig gedruckt und beendet.