Il tuo programma deve prendere un input ( nai fini della descrizione) e generare tutte le permutazioni di un numero ncomposto da cifre lunghe senza cifre ripetitive, in cui ciascuna delle cifre che precedono e incluso il suo indice sono divisibili per il posto nel numero che cade .

Puoi leggere i numeri magici qui .

Regole:

• 1 <= n <= 10
• Nessuna cifra può essere ripetuta
• Lo 0 iniziale deve essere presente (se applicabile)
• La prima xcifra della prima cifra del numero (che inizia con il primo carattere come 1) deve essere divisibile per x, ovvero in 30685, 3è divisibile per 1, 30è divisibile per 2, 306è divisibile per 3, 3068è divisibile per 4 ed 30685è divisibile per 5 .
• Il programma deve prendere un numero intero come input (attraverso la riga di comando, come argomento di funzione, ecc.) E stampare tutte le permutazioni che soddisfano le regole.
• L'output deve essere separato da 1 o più caratteri di spazio bianco
• Le permutazioni possono iniziare e con zero (quindi non sono numeri tecnicamente magici).
• L'ordine di uscita non ha importanza
• Non è necessario gestire input imprevisti
• Vince il numero minimo di caratteri in byte

Esempi

Dato 1:

0
1
2
3
4
5
6
7
8
9

Dato 2:

02
04
06
08
10
12
14
16
18
20
24
26
28
30
32
34
36
38
40
42
46
48
50
52
54
56
58
60
62
64
68
70
72
74
76
78
80
82
84
86
90
92
94
96
98

Dato 10:

3816547290

Ringraziamo Pizza Hut e John H. Conway per il puzzle originale (Opzione A). Grazie a @Mego e @ sp3000 per i loro collegamenti .

Gelatina , 20 17 16 byte

QḣQV%S
ØDṗçÐḟRj⁷

Questo è molto lento e richiede molta memoria ... Provalo online!

Come funziona

ØDṗçÐḟRj⁷  Main link. Input: n (integer)

ØD         Yield d := '0123456789'.
  ṗ        Compute the nth Cartesian power of d.
      R    Range; yield [1, ..., n].
    Ðḟ     Filter false; keep strings of digits for which the following yields 0.
   ç         Apply the helper link to each digit string and the range to the right.
       j⁷  Join the kept strings, separating by linefeeds.


QḣQḌ%S     Helper link. Arguments: s (digit string), r (range from 1 to n)

Q          Unique; deduplicate s.
 ḣ         Head; get the prefixes of length 1, ..., n or less.
           If s had duplicates, the final prefixes fill be equal to each other.
  Q        Unique; deduplicate the array of prefixes.
   V       Eval all prefixes.
    %      Compute the residues of the kth prefixes modulo k.
           If s and the array of prefixes have different lengths (i.e., if the
           digits are not unique), some right arguments of % won't have corr. left
           arguments. In this case, % is not applied, and the unaltered right
           argument is the (positive) result.
     S     Add all residues/indices. This sum is zero iff all digits are unique
           and the kth prefixes are divisible by k.

JavaScript (Firefox 30-57), 77 byte

f=n=>n?[for(s of f(n-1))for(c of"0123456789")if(s.search(c)+(s+c)%n<0)s+c]:[""]

Modifica: salvato 1 byte grazie a @ edc65.

Pyth, 19 byte

jf!s%VsM._TS;.PjkUT

Dimostrazione

Una soluzione di forza bruta. Spiegazione da seguire. Ispirazione grazie a FryAmTheEggman

22 byte

juf!%sThH{I#sm+LdTGQ]k

Dimostrazione

I numeri vengono creati e memorizzati come stringhe e convertiti in soli per verificare la divisibilità.

Spiegazione:

juf!%sThH{I#sm+LdTGQ]k
 u                 Q]k    Apply the following input many times, starting with ['']
             m    G       For each string at the previous step,
              +LdT        Append each digit to it
            s             Concatenate
         {I#              Filter out strings with repeats
  f                       Filter on
     sT                   The integer
    %  hH                 Mod the 1 indexed iteration number
   !                      Is zero.
j                         Join on newlines.

MATL , 30 byte

4Y2Z^!"@Sd@!U10G:q^/kPG:\~h?@!

Provalo online!

È molto lento. Perché input 3ci vogliono pochi secondi nel compilatore online. Per vedere i numeri che appaiono uno per uno, includi Da alla fine del codice .

Spiegazione

4Y2       % predefined literal: string '0123456789'
Z^        % implicit input. Cartesian power: 2D char array. Each number is a row
!         % transpose
"         % for each column
  @       %   push current column
  Sd      %   sort and compute consecutive differences (*)
  @!U     %   push current column. Convert to number
  10G:q^  %   array [1 10 100 ... 10^(n-1)], where n is the input
  /k      %   divide element-wise. Round down
  P       %   reverse array
  G:      %   array [1 2 ... n]
  \~      %   modulo operation, element-wise. Negate: gives 1 if divisible (**)
  h       %   concatenate (*) and (**). Truthy if all elements are nonzero
  ?       %   if so
    @!    %     current number as a row array of char (string)
          %   implicitly end if
          % implicitly end if
          % implicitly display stack contents

Rubino, 87 byte

Soluzione ricorsiva di base.

f=->n,x="",j=1{j>n ?puts(x):([*?0..?9]-x.chars).map{|i|f[n,x+i,j+1]if((x+i).to_i)%j<1}}

Se ti è permesso restituire un elenco delle permutazioni invece di stampare, 85 byte:

f=->n,x="",j=1{j>n ?x:([*?0..?9]-x.chars).map{|i|f[n,x+i,j+1]if((x+i).to_i)%j<1}-[p]}

Python, 132 byte

lambda n:[x for x in map(("{:0%s}"%n).format,(range(10**n)))if all(int(x[:i])%i<1and len(set(x))==len(x)for i in range(1,len(x)+1))]

Eliminati 26 byte eliminandoli itertools, grazie a Sp3000 per avermi fatto capire che non avrei dovuto usarlo.

Eliminati 2 byte utilizzando una comprensione dell'elenco anziché filter, grazie ancora a Sp3000 per il suggerimento.

Provalo online: Python 2 , Python 3