Su programa debe tomar una entrada ( npara fines de descripción) y generar todas las permutaciones de un número de ndígitos largos sin dígitos repetidos, donde cada uno de los dígitos que preceden e incluyen su índice son divisibles por el lugar en el número que corresponde. .

Puedes leer sobre los números mágicos aquí .

Reglas:

• 1 <= n <= 10
• No se pueden repetir dígitos
• El 0 inicial debe estar presente (si corresponde)
• El 1 ° al 3 x° dígito del número (comenzando con el primer carácter como 1) debe ser divisible por x, es decir 30685, en , 3es divisible por 1, 30es divisible por 2, 306es divisible por 3, 3068es divisible por 4 y30685 es divisible entre 5 .
• El programa debe tomar un número entero como entrada (a través de la línea de comando, como argumento de función, etc.) e imprimir todas las permutaciones que satisfacen las reglas.
• La salida debe estar separada por 1 o más caracteres de espacio en blanco
• Las permutaciones pueden comenzar y con cero (por lo que técnicamente no son números mágicos).
• El orden de salida no importa
• Usted no tiene que manejar la entrada inesperada
• Menos caracteres en bytes gana

Ejemplos

Dado 1:

0
1
2
3
4
5
6
7
8
9

Dado 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

Dado 10:

3816547290

Gracias a Pizza Hut y John H. Conway por el rompecabezas original (Opción A). Gracias a @Mego y @ sp3000 por sus enlaces .

Jalea , 20 17 16 bytes

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

Esto es muy lento y requiere mucha memoria ... ¡ Pruébelo en línea!

Cómo funciona

Ø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 bytes

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

Editar: guardado 1 byte gracias a @ edc65.

Pyth, 19 bytes

jf!s%VsM._TS;.PjkUT

Demostración

Una solución de fuerza bruta. Explicación a seguir. Inspiración gracias a FryAmTheEggman

22 bytes

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

Demostración

Los números se crean y almacenan como cadenas, y solo se convierten en int para verificar la divisibilidad.

Explicación:

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 bytes

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

Pruébalo en línea!

Es muy lento. Porque input 3lleva unos segundos en el compilador en línea. Para ver los números que aparecen uno por uno, incluya un Dal final del código .

Explicación

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

Rubí, 87 bytes

Solución recursiva básica.

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

Si puede devolver una lista de las permutaciones en lugar de imprimir, 85 bytes:

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 bytes

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

Eliminé 26 bytes al deshacerme itertools, gracias a Sp3000 por hacerme darme cuenta de que no debería estar usándolo.

Se eliminaron 2 bytes utilizando una comprensión de la lista en lugar de filter, gracias de nuevo a Sp3000 por el consejo.

Pruébelo en línea: Python 2 , Python 3