# Magic number of a given length

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

Edit: Saved 1 byte thanks to @edc65.

## Jelly, ~~20~~ ~~17~~ 16 bytes

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

This is *very* slow and memory intensive... Try it online!

### How it works

```
Ø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.
```

## MATL, 30 bytes

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

Try it online!

It's very slow. For `input 3`

it takes a few seconds in the online compiler. To see the numbers appearing one by one, include a `D`

at the end of the code.

### Explanation

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