Votre programme doit prendre une entrée ( nà des fins de description) et sortir toutes les permutations d'un nombre ncomposé de chiffres longs sans répétition de chiffres, où chacun des chiffres précédant et incluant son index est divisible par la place dans le nombre qu'il tombe .

Vous pouvez lire sur les nombres magiques ici .

Règles:

• 1 <= n <= 10
• Aucun chiffre ne peut être répété
• Le 0 de tête doit être présent (le cas échéant)
• Le premier au xtroisième chiffre du nombre (en commençant par le premier caractère 1) doit être divisible par x, c'est-à-dire en 30685, 3est divisible par 1, 30est divisible par 2, 306est divisible par 3, 3068est divisible par 4 et 30685est divislbe par 5 .
• Le programme doit prendre un entier en entrée (via la ligne de commande, comme argument de fonction, etc.) et imprimer toutes les permutations qui satisfont aux règles.
• La sortie doit être séparée par au moins un espace blanc
• Les permutations peuvent commencer et avec zéro (ce ne sont donc pas des nombres techniquement magiques).
• L'ordre de sortie n'a pas d'importance
• Vous n'avez pas besoin de gérer une entrée inattendue
• Le moins de caractères en octets gagne

Exemples

Étant donné 1:

0
1
2
3
4
5
6
7
8
9

Étant donné 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

Étant donné 10:

3816547290

Nous remercions Pizza Hut et John H. Conway pour le puzzle original (option A). Merci à @Mego et @ sp3000 pour leurs liens .

Gelée , 20 17 16 octets

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

C'est très lent et gourmand en mémoire ... Essayez-le en ligne!

Comment ça fonctionne

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

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

Edit: 1 octet enregistré grâce à @ edc65.

Pyth, 19 octets

jf!s%VsM._TS;.PjkUT

Manifestation

Une solution de force brute. Explication à suivre. Inspiration grâce à FryAmTheEggman

22 octets

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

Manifestation

Les nombres sont construits et stockés sous forme de chaînes, et uniquement convertis en ints pour vérifier la divisibilité.

Explication:

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 octets

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

Essayez-le en ligne!

C'est très lent. Car input 3cela prend quelques secondes dans le compilateur en ligne. Pour voir les chiffres apparaître un par un, ajoutez un Dà la fin du code .

Explication

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

Rubis, 87 octets

Solution récursive de 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}}

Si vous êtes autorisé à renvoyer une liste des permutations au lieu d'imprimer, 85 octets:

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 octets

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

A chuté de 26 octets en se débarrassant de itertools, grâce au Sp3000 pour m'avoir fait réaliser que je ne devrais pas l'utiliser.

Supprimé 2 octets en utilisant une compréhension de liste plutôt que filter, merci encore au Sp3000 pour l'astuce.

Essayez-le en ligne: Python 2 , Python 3