Em um episódio recente de QI , os 5 primeiros múltiplos de 142857 foram descritos como anagramas do número original. É claro que qualquer pessoa com mais do que um conhecimento passageiro desse número saberá que esses números são realmente cíclicos, não apenas anagramas. Mas isso me fez pensar.

Escreva um programa ou função que produza todos os números de seis ou menos dígitos que possuam um fator adequado que seja um anagrama. A lista deve começar com os seguintes números:

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)

Se preferir, você pode encontrar números que tenham um anagrama que seja um fator adequado do número, mas lembre-se de excluir os zeros à esquerda dos seus anagramas.

Esse é o código golf, então o código mais curto em bytes que não quebra brechas padrão vence.

Mathematica (ambiente REPL), 75 74 bytes

Agradecemos à ngenisis por reforçar isso com um byte!

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

Sort/@IntegerDigits@Divisors@#produz uma lista ordenada de dígitos para cada divisor de seu argumento; o próprio número de entrada é um divisor; portanto, sua lista ordenada de dígitos é o último. Most@#~MemberQ~Lastdetecta se a última lista classificada de dígitos também aparece na lista anterior ao último elemento. E Select[Range[10!],...]retém apenas os números inteiros até 3.628.800 que passam neste teste (esse limite escolhido porque é um byte menor que 10 ⁶ ). Ele roda em cerca de 5 minutos no meu computador, produzindo uma lista de 494 números, o maior dos quais é 3.427.191; existem 362 números até 10 ⁶ , o maior dos quais é 989.901.

Gelatina , 12 bytes

ÆḌṢ€ċṢ
ȷ6ÇÐf

Experimente online! (usa cinco ou menos dígitos devido ao limite de tempo do TIO)

Verficação

$ 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

Como funciona

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

Braquilog , 12 bytes

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

Experimente online!

Isso pode esgotar o tempo limite antes de imprimir qualquer coisa (e, se não ocorrer, será possível imprimir apenas 3105).

Explicação

Isso imprime esses números indefinidamente, pois o autor disse que era aceitável que o programa imprimisse números maiores que 6 dígitos.

Isso é muito lento; você pode usar este programa (e alterar 8300por qualquer N) para começar a imprimir a partir de números estritamente maiores que 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

Como @ ais523 apontou, precisamos de um corte para evitar a impressão de um número várias vezes se vários de seus fatores forem permutações dele.

JavaScript (ES6), 103 … 96 94 bytes

Uma função anônima que retorna a matriz de números inteiros correspondentes.

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

Formatado e comentado

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

Estatísticas do divisor

Para inteiros seis dígitos, cada relação 2da 9entre um número inteiro de harmonização ne a sua anagrama for encontrado pelo menos uma vez. Mas alguns deles aparecem apenas algumas vezes:

 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

Teste

O teste abaixo é limitado ao intervalo, [1 ... 39999]para que não demore muito tempo para concluir.

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{

Experimente aqui!

Deve gerar todos os números como esse, mas o tempo limite será excedido.

Teste o algoritmo aqui!

Perl 6 , 59 bytes

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

Solução terrivelmente lenta de força bruta.

Ele retorna uma sequência lenta, para que eu possa verificar os primeiros resultados, mas não alcançará todos os resultados em tempo razoável. (Devo marcar como não concorrente?)

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
}

Experimente online!

(Este programa é razoavelmente rápido - foram necessários apenas 14 minutos para percorrer todos os números de 6 dígitos do meu MacBook. Infelizmente, o TIO excede o tempo limite porque impõe um limite de tempo de execução de 1 minuto, o que é tempo suficiente para concluir os números de 5 dígitos ou mais.)

Utilitários Bash + Unix, 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

Isso é mais curto que a versão pura do bash, mas é um pouco mais lento, provavelmente devido em boa parte a todos os bifurcações.

05AB1E , 15 bytes

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

Explicação:

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

Experimente online! (isso não vai funcionar, o tempo limite será excedido)

Japonês , 23 bytes

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

Experimente online! Observe que o código vinculado calcula apenas até 1e4 porque 1e6 atinge o tempo limite no TIO.

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

Tempo limite excedido no TIO devido ao loop infinito.
Economizamos 2 bytes, pois poderíamos gerar mais de 6 dígitos, de acordo com o comentário dos OPs.

[NѨ€{N{å–

Experimente online!

Explicação

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

Lote, 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%

Lento. Assim, leva mais de um dia para terminar no meu PC. Explicação: a csub - rotina divide seus dois primeiros argumentos. Se o restante for zero, ele calculará o hash do resultado calculando a soma das enésimas potências de 8 para cada dígito. Essa função hash, roubada da resposta bash, apenas colide com anagramas. (Funcionaria para números de sete dígitos, mas não tenho quinze dias.) O terceiro argumento é subtraído e a sub-rotina sai com um resultado verdadeiro se este for zero. A nsub-rotina chama a csub - rotina uma vez para calcular o hash, depois mais oito vezes para comparar o hash; se encontrar uma colisão, imprime ne sai da sub-rotina mais cedo.