QI 의 최근 에피소드에서 142857의 처음 5 배는 원래 숫자의 아나그램으로 설명되었습니다. 물론, 그 숫자에 대한 지식을 넘어서는 사람은 그 숫자가 단지 아나그램이 아니라 주기적이라는 것을 알게 될 것입니다. 그러나 그것은 나를 생각하게했다.

6 자 이하 자릿수를 모두 출력하는 프로그램이나 함수를 작성하십시오. 목록은 다음 숫자로 시작해야합니다.

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)

원하는 경우 숫자의 적절한 요소 인 아나그램이있는 숫자를 찾을 수 있지만 아나그램에서 선행 0을 제외하도록주의하십시오.

이것은 코드 골프이므로 표준 허점을 깨지 않는 가장 짧은 바이트 코드입니다.

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 ⁶ 보다 1 바이트 더 짧기 때문에 선택된 범위 ). 내 컴퓨터에서 약 5 분 안에 실행되며 494 개의 숫자 목록이 표시되며 그 중 가장 큰 숫자는 3,427,191입니다. 10 ⁶ 까지의 362 개의 숫자가 있으며, 그 중 가장 큰 숫자 는 989,901입니다.

젤리 , 12 바이트

ÆḌṢ€ċṢ
ȷ6ÇÐf

온라인으로 사용해보십시오! (TIO의 시간 제한으로 인해 5 자리 이하의 숫자를 사용함)

에서 인증 할

$ 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)보다 stricly 큰 숫자에서 인쇄를 시작합니다 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이 지적했듯이 여러 요소가 순열 인 경우 여러 번 인쇄하지 않도록 잘라 내야합니다.

자바 스크립트 (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에 9일치하는 정수 사이 n및 철자 바꾸기 번 적어도 발생된다. 그러나 그중 일부는 몇 번만 나타납니다.

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

파이크, 14 바이트

~1#`Sili-m`mS{

여기 사용해보십시오!

이 같은 모든 숫자를 출력해야하지만 시간이 초과됩니다.

여기서 알고리즘을 테스트하십시오!

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

온라인으로 사용해보십시오!

(이 프로그램은 상당히 빠릅니다. MacBook의 6 자리 숫자를 모두 실행하는 데 14 분 밖에 걸리지 않았습니다. 불행히도 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

분기에가는 이것은 아마도 때문에 좋은 부분 모두에, 꽤 느린 순수 배쉬 버전보다 짧은,하지만.

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

온라인으로 사용해보십시오! 링크 된 코드는 TIO에 밖으로 1E4 1E6 때문에 배까지 계산합니다.

파이썬 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에서 시간이 초과되었습니다.
OP 주석에 따라 6 자리 이상의 숫자를 출력 할 수 있으므로 2 바이트를 절약했습니다.

[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서브 루틴은 처음 두 인수를 나눕니다. 나머지가 0이면 각 자릿수에 대한 n의 거듭 제곱의 합을 계산하여 결과의 ​​해시를 계산합니다. bash 답변에서 도난당한이 해시 함수는 아나그램에서만 충돌합니다. (7 자리 숫자에 대해서는 작동하지만 2 주일은 없습니다.) 세 번째 인수는 빼고 서브 루틴은 0이면 정확한 결과로 종료됩니다. n서브 루틴을 호출 c해시를 비교 한 후, 여덟 번 더 해시를 계산하면 서브 루틴을; 충돌을 발견 n하면 서브 루틴을 일찍 인쇄 하고 종료합니다.