# Seqindignot sequence

## Python 2, ~~92~~ ~~91~~ ~~89~~ 88 bytes

```
a=()
i=0
exec"x=0\nwhile set(`x`)&set(`i`)or x in a:x+=1\na+=x,;i+=1;"*-~input()
print a
```

Try it online!

Prints a list of the first `n+1`

numbers

Different approach, which is a lot faster:

## Python 2, 96 bytes

```
n=input()
r=range(9*n)
i=0
exec"x=0\nwhile set(`r[x]`)&set(`i`):x+=1\nprint r.pop(x),;i+=1;"*-~n
```

Try it online!

### Haskell, ~~80~~ 69 bytes

```
f n=[x|x<-[0..],all(`notElem`show n)$show x,all(/=x)$f<$>[0..n-1]]!!0
```

Try it online!

Very slow for large `n`

.

```
f n=
[x|x<-[0..] ] !!0 -- pick the first of all 'x' from [0..]
-- where
all(`notElem`show n)$show x -- no digit of 'n' appears in 'x', and
all(/=x) -- 'x' is not seen before, i.e. not in the list
f<$>[0..n-1] -- 'f' mapped to [0..n-1]
```

Edit: @Laikoni saved 10 bytes. Thanks!

## Pyth, 18 bytes

```
u+Gf!|}[email protected]`H`T0hQY
```

**Try it here!** or **Check more test cases!**

Note that this returns the entire sequence up to index **N**, but the link returns the last number only, by prepending an `e`

(end). If you want to see the raw value returned by this program, just remove it.

### How it works

u+Gf!|}[email protected]`H`T0hQY - Full program. u ... hQY - Reduce hQ (the input incremented) from left to right, with the function ...(G, H), with starting value Y (the empty list). G is the current value and H is the iteration index. f 0 - First integer starting from 0, that satisfies the following: }TG - Appears in G... | @`H`T - Or its (string) intersection with the current index (H) is non-empty. ! - Logical NOT (boolean negation). +G - Append the value obtained above to the current value (G). This becomes the given value for the next iteration. - Implicitly print all intermediate results, or add e to print the last one.