En un episodio reciente de QI , los primeros 5 múltiplos de 142857 se describieron como anagramas del número original. Por supuesto, cualquiera con un conocimiento más que pasajero de ese número sabrá que esos números son realmente cíclicos, no solo anagramas. Pero eso me puso a pensar.

Escriba un programa o función que genere todos los números de seis dígitos o menos que tengan un factor apropiado que sea un anagrama de sí mismo. La lista debe comenzar con los siguientes 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)

Si lo prefiere, puede encontrar números que tengan un anagrama que sea un factor apropiado del número, pero tenga cuidado de excluir los ceros iniciales de sus anagramas.

Este es el código de golf, por lo que gana el código más corto en bytes que no rompe las lagunas estándar.

Mathematica (entorno REPL), 75 74 bytes

¡Gracias a ngenisis por reforzar esto por un byte!

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

Sort/@IntegerDigits@Divisors@#produce una lista ordenada de dígitos para cada divisor de su argumento; el número de entrada es en sí mismo un divisor, por lo que su lista ordenada de dígitos es la última. Most@#~MemberQ~Lastdetecta si esa última lista ordenada de dígitos también aparece en la lista anterior al último elemento. Y Select[Range[10!],...]retiene solo aquellos enteros de hasta 3,628,800 que pasan esta prueba (ese límite elegido porque es un byte más corto que 10 ⁶ ). Se ejecuta en aproximadamente 5 minutos en mi computadora, produciendo una lista de 494 números, el mayor de los cuales es 3,427,191; hay 362 números hasta 10 ⁶ , el mayor de los cuales es 989,901.

Jalea , 12 bytes

ÆḌṢ€ċṢ
ȷ6ÇÐf

Pruébalo en línea! (usa cinco dígitos o menos debido al límite de tiempo de TIO)

Verificación

$ 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

Cómo 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.

Brachylog , 12 bytes

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

Pruébalo en línea!

Sin embargo, esto podría exceder el tiempo de espera antes de imprimir cualquier cosa (y si no lo hace, solo podrá imprimir 3105).

Explicación

Esto imprime esos números indefinidamente, ya que el autor dijo que era aceptable que el programa imprimiera números de más de 6 dígitos.

Esto es demasiado lento; puede usar este programa (y cambiar 8300por cualquiera N) para comenzar a imprimir desde números estrictamente mayores 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 señaló @ ais523, necesitamos un corte para evitar imprimir un número varias veces si varios de sus factores son permutaciones del mismo.

JavaScript (ES6), 103 ... 96 94 bytes

Una función anónima que devuelve la matriz de enteros coincidentes.

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

Formateado y 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
  )                                 //

Estadísticas del divisor

Para enteros 6 dígitos, cada relación de 2a 9entre un número entero de adaptación ny su anagrama se encuentra al menos una vez. Pero algunos de ellos aparecen solo algunas veces:

 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

Prueba

La prueba a continuación se limita al rango, [1 ... 39999]por lo que no lleva mucho tiempo completarla.

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{

Pruébalo aquí!

Debería mostrar todos los números como este pero se agota el tiempo de espera.

¡Prueba el algoritmo aquí!

Perl 6 , 59 bytes

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

Solución de fuerza bruta terriblemente lenta.

Devuelve una secuencia perezosa, por lo que podría verificar los primeros resultados, pero no alcanzará todos los resultados en un tiempo razonable. (¿Debo marcarlo como no competitivo?)

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
}

Pruébalo en línea!

(Este programa es razonablemente rápido: solo tardó 14 minutos en recorrer todos los números de 6 dígitos de mi MacBook. Desafortunadamente, TIO agota el tiempo de espera porque impone un límite de tiempo de ejecución de 1 minuto, que es solo el tiempo suficiente para completarlo. los números de 5 dígitos más o menos.)

Bash + Unix utilidades, 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

Esto es más corto que la versión de bash puro, pero bastante más lento, presumiblemente debido en buena parte a toda la bifurcación.

05AB1E , 15 bytes

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

Explicación:

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

Pruébalo en línea! (esto no funcionará, se agotará el tiempo)

Japt , 23 bytes

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

Pruébalo en línea! Tenga en cuenta que el código vinculado solo calcula hasta 1e4 porque 1e6 agota el tiempo de espera en 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

Se agotó el tiempo de espera en TIO debido al bucle infinito.
Se guardaron 2 bytes ya que podríamos generar números de más de 6 dígitos de acuerdo con el comentario de los OP.

[NѨ€{N{å–

Pruébalo en línea!

Explicació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

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. Como en, lleva más de un día terminar en mi PC. Explicación: la csubrutina divide sus dos primeros argumentos. Si el resto es cero, entonces calcula el hash del resultado calculando la suma de las enésimas potencias de 8 para cada dígito. Esta función hash, robada de la respuesta bash, solo colisiona en anagramas. (Funcionaría para números de siete dígitos, pero no tengo toda la quincena). El tercer argumento se resta, y la subrutina sale con un resultado verdadero si es cero. La nsubrutina llama a la csubrutina una vez para calcular el hash, luego ocho veces más para comparar el hash; Si encuentra una colisión, imprime ny sale temprano de la subrutina.