In un recente episodio di QI , i primi 5 multipli del 142857 furono descritti come anagrammi del numero originale. Naturalmente, chiunque abbia una conoscenza più che passante di quel numero saprà che quei numeri sono in realtà ciclici, non solo anagrammi. Ma questo mi ha fatto pensare.

Si prega di scrivere un programma o una funzione che emetta tutti i numeri di sei o meno cifre che hanno un fattore proprio che è un anagramma di se stesso. L'elenco dovrebbe iniziare con i seguenti numeri:

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 preferisci, puoi trovare numeri che hanno un anagramma che è un fattore proprio del numero, ma fai attenzione ad escludere gli zeri iniziali dai tuoi anagrammi.

Questo è il golf del codice, quindi vince il codice più breve in byte che non rompe nessuna scappatoia standard.

Mathematica (ambiente REPL), 75 74 byte

Grazie a ngenisis per averlo stretto di un byte!

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

Sort/@IntegerDigits@Divisors@#produce un elenco ordinato di cifre per ogni divisore del suo argomento; il numero di input è esso stesso un divisore, quindi il suo elenco ordinato di cifre è l'ultimo. Most@#~MemberQ~Lastrileva se l'ultimo elenco ordinato di cifre appare anche nell'elenco prima dell'ultimo elemento. E Select[Range[10!],...]conserva solo quegli interi fino a 3.628.800 che superano questo test (quel limite scelto perché è un byte più corto di 10 ⁶ ). Funziona in circa 5 minuti sul mio computer, producendo un elenco di 494 numeri, il più grande dei quali è 3.427.191; ci sono 362 numeri fino a 10 ⁶ , il più grande dei quali è 989.901.

Gelatina , 12 byte

ÆḌṢ€ċṢ
ȷ6ÇÐf

Provalo online! (utilizza cinque o meno cifre a causa del limite di tempo di TIO)

Verfication

$ 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

Come funziona

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

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

Provalo online!

Questo potrebbe scadere prima di stampare qualsiasi cosa (e in caso contrario si potrà solo stampare 3105).

Spiegazione

Questo stampa quei numeri indefinitamente, poiché l'autore ha detto che era accettabile che il programma stampasse numeri più grandi di 6 cifre.

Questo è troppo lento; è possibile utilizzare questo programma (e modificarlo 8300con qualsiasi N) per iniziare a stampare da numeri strettamente maggiori di 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

Come ha sottolineato @ ais523, abbiamo bisogno di un taglio per evitare di stampare un numero più volte se molti dei suoi fattori ne sono permutazioni.

JavaScript (ES6), 103 … 96 94 byte

Una funzione anonima che restituisce la matrice di numeri interi corrispondenti.

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

Formattato e commentato

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

Statistiche Divisor

Per interi 6 cifre, ciascun rapporto da 2a 9tra un numero intero corrispondente ne il suo anagramma si incontra almeno una volta. Ma alcuni di loro appaiono solo poche volte:

 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

Test

Il test di seguito è limitato all'intervallo in [1 ... 39999]modo da non richiedere troppo tempo per il completamento.

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 byte

~1#`Sili-m`mS{

Provalo qui!

Dovrebbe produrre tutti i numeri in questo modo ma va in timeout.

Prova l'algoritmo qui!

Perl 6 , 59 byte

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

Soluzione a forza bruta terribilmente lenta.

Restituisce una sequenza pigra, quindi potrei controllare i primi risultati, ma non raggiungerà tutti i risultati in tempi ragionevoli. (Devo contrassegnarlo come non competitivo?)

Pure Bash , 128 126 122 121 120 byte

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
}

Provalo online!

(Questo programma è ragionevolmente veloce - ci sono voluti solo 14 minuti per scorrere tutti i numeri a 6 cifre sul mio MacBook. Sfortunatamente TIO scade perché impone un limite di tempo di esecuzione di 1 minuto, che è solo il tempo sufficiente per passare i numeri di 5 cifre o giù di lì.)

Utilità Bash + Unix, 117 byte

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

Questo è più corto della versione bash pura, ma un po 'più lento, presumibilmente a causa in buona parte di tutto il bivio in corso.

05AB1E , 15 byte

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

Spiegazione:

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

Provalo online! (questo non funzionerà, andrà in timeout)

Japt , 23 byte

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

Provalo online! Si noti che il codice collegato calcola solo fino a 1e4 perché 1e6 va in timeout su TIO.

Python 2, 98 byte

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 byte

Timeout su TIO a causa del loop infinito.
Salvati 2 byte perché potremmo produrre più di 6 cifre secondo il commento dei PO.

[NѨ€{N{å–

Provalo online!

Spiegazione

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

Lotto, 263 byte

@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. Come in, impiega un giorno a finire sul mio PC. Spiegazione: la csubroutine divide i suoi primi due argomenti. Se il resto è zero, calcola quindi l'hash del risultato calcolando la somma dell'ennesimo potere di 8 per ogni cifra. Questa funzione hash, rubata dalla risposta bash, si scontra solo con gli anagrammi. (Funzionerebbe per numeri di sette cifre ma non ho tutte le due settimane.) Il terzo argomento viene sottratto e la subroutine esce con un risultato veritiero se questo è zero. La nsubroutine chiama la csubroutine una volta per calcolare l'hash, quindi altre otto volte per confrontare l'hash; se rileva una collisione, stampa ned esce anticipatamente dalla subroutine.