在最近发生的QI中，将142857的前5个倍数描述为原始数字的字谜。当然，只要对数字有足够的了解，任何人都将知道这些数字实际上是循环的，而不仅仅是字谜。但这让我思考。

请编写一个程序或函数，以输出所有六位数或更少的数字，这些数字或数字具有其自身的字谜。该列表应以以下数字开头：

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)

如果愿意，您可以找到带有字谜的数字，该字谜是该数字的适当因数，但请注意从字谜中排除前导零。

这是代码高尔夫，因此以字节为单位的最短代码不会破坏任何标准漏洞。

Mathematica（REPL环境），75 74字节

感谢ngenisis，将其收紧了一个字节！

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

Sort/@IntegerDigits@Divisors@#为其参数的每个除数生成一个数字排序列表；输入数字本身就是除数，因此其排序的数字列表是最后一个数字。Most@#~MemberQ~Last检测最后排序的数字列表是否也出现在最后一个元素之前的列表中。并且Select[Range[10!],...]仅保留通过此测试的最大整数3,628,800（选择该界限，因为它比10 ⁶短一个字节）。它在我的计算机上运行约5分钟，产生了494个数字的列表，其中最大的是3,427,191；有362个数字，最大为10 ⁶，其中最大为989,901。

果冻，12字节

ÆḌṢ€ċṢ
ȷ6ÇÐf

在线尝试！（由于TIO的时间限制，请使用五位或更少的数字）

验证

$ 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

怎么运行的

ȷ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个字节

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

在线尝试！

但是在打印任何内容之前这可能会超时（如果没有，则只能打印3105）。

说明

这将无限期地打印这些数字，因为作者说程序可以打印大于6位的数字是可以接受的。

这太慢了；您可以使用该程序（并进行更改8300任意N）从大于的数字开始打印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

正如@ ais523所指出的，如果它的几个因素是其排列的结果，我们需要进行裁切以避免多次打印数字。

JavaScript（ES6），103 … 96 94字节

返回返回整数数组的匿名函数。

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

格式化和评论

_ =>                                // 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
  )                                 //

除数统计

对于6位整数，匹配整数与它的字谜之间从2到的每个比率至少遇到一次。但是其中一些仅出现几次：9n

 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

测试

以下测试仅限于该范围[1 ... 39999]，因此不需要太多时间即可完成。

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个字节

~1#`Sili-m`mS{

在这里尝试！

应该输出所有数字，但是超时。

在这里测试算法！

Perl 6、59字节

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

极慢的蛮力解决方案。

它返回一个惰性序列，因此我可以检查前几个结果，但是在合理的时间内不会达到所有结果。（我应该将其标记为不竞争吗？）

纯击，128个 126 122 121 120字节

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
}

在线尝试！

（此程序相当快-仅用14分钟即可运行MacBook上的所有6位数字。不幸的是，TIO超时，因为它规定了1分钟的运行时间限制，这仅够通过5位数字左右。）

Bash + Unix实用程序，117字节

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

它比纯bash版本要短一些，但是要慢得多，大概部分原因是所有分支都在进行。

05AB1E，15个字节

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

说明：

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

在线尝试！（这行不通，会超时）

Japt，23个字节

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

在线尝试！请注意，由于1e6在TIO上超时，因此链接的代码最多只能计算1e4。

Python 2，98个字节

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字节

由于无限循环，TIO超时。
节省了2个字节，因为根据操作员的注释，我们可以输出超过6位数字。

[NѨ€{N{å–

在线尝试！

说明

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

批处理，263字节

@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%

慢。在这种情况下，需要花费一天的时间才能在我的PC上完成操作。说明：该c子例程将其前两个参数相除。如果余数为零，则通过为每个数字计算n的8次幂的和来计算结果的哈希。此哈希函数是从bash答案中窃取的，仅与字谜碰撞。（它适用于七个数字，但我两周都没有。）减去第三个参数，如果该参数为零，则该子例程以真实结果退出。该n子程序调用c子程序一次来计算哈希值，然后八点多的时间比较散; 如果发现冲突，它将打印n并提前退出子程序。