Ihr Programm muss eine Eingabe ( nzum Zwecke der Beschreibung) annehmen und alle Permutationen einer Zahl ausgeben, die nZiffern ohne wiederholte Ziffern lang sind, wobei jede der Ziffern vor und einschließlich ihres Index durch die Stelle in der Zahl teilbar ist, auf die sie fällt .

Über magische Zahlen können Sie hier lesen .

Regeln:

• 1 <= n <= 10
• Es dürfen keine Ziffern wiederholt werden
• Die führende 0 muss vorhanden sein (falls zutreffend)
• Die 1. bis x10. Ziffer der Zahl (beginnend mit dem ersten Zeichen als 1) muss teilbar sein durch x, dh in 30685, 3ist teilbar durch 1, 30ist teilbar durch 2, 306ist teilbar durch 3, 3068ist teilbar durch 4 und 30685ist teilbar durch 5 .
• Das Programm muss eine Ganzzahl als Eingabe annehmen (über die Befehlszeile, als Funktionsargument usw.) und alle Permutationen ausgeben, die den Regeln entsprechen.
• Die Ausgabe muss durch mindestens ein Leerzeichen getrennt werden
• Permutationen können mit Null beginnen (also technisch gesehen keine magischen Zahlen).
• Die Reihenfolge der Ausgabe spielt keine Rolle
• Sie müssen nicht mit unerwarteten Eingaben umgehen
• Die wenigsten Zeichen in Bytes gewinnen

Beispiele

Gegeben 1:

0
1
2
3
4
5
6
7
8
9

Gegeben 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

Gegeben 10:

3816547290

Dank an Pizza Hut & John H. Conway für das ursprüngliche Rätsel (Option A). Vielen Dank an @Mego und @ sp3000 für die Links .

Jelly , 20 17 16 Bytes

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

Dies ist sehr langsam und speicherintensiv ... Probieren Sie es online!

Wie es funktioniert

Ø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]:[""]

Bearbeiten: 1 Byte dank @ edc65 gespeichert.

Pyth, 19 Bytes

jf!s%VsM._TS;.PjkUT

Demonstration

Eine Brute-Force-Lösung. Erklärung folgt. Inspiration dank FryAmTheEggman

22 Bytes

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

Demonstration

Zahlen werden als Zeichenfolgen erstellt und gespeichert und nur in Ints konvertiert, um die Teilbarkeit zu überprüfen.

Erläuterung:

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?@!

Probieren Sie es online!

Es ist sehr langsam. Im input 3Online-Compiler dauert es einige Sekunden. Fügen Sie am Ende des Codes ein ein, umD zu sehen, wie die Zahlen einzeln angezeigt werden .

Erläuterung

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

Ruby, 87 Bytes

Grundlegende rekursive Lösung.

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

Wenn Sie anstelle des Druckens eine Liste der Permutationen zurückgeben dürfen, sind dies 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 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))]

Wir haben 26 Bytes itertoolsverloren, weil ich dank Sp3000 festgestellt habe, dass ich es nicht verwenden sollte.

Es wurden 2 Bytes filtergelöscht, indem ein Listenverständnis verwendet wurde, und nicht . Nochmals vielen Dank an Sp3000 für den Tipp.

Probieren Sie es online aus: Python 2 , Python 3