# Determining Integer Depth in Python

## The challenge

The `depth`

of an integer `n`

is defined to be how many multiples of `n`

it is necessary to compute before all `10`

digits have appeared at least once in some multiple.

**Example:**

```
let see n=42
Multiple value digits comment
42*1 42 2,4
42*2 84 8 4 existed
42*3 126 1,6 2 existed
42*4 168 - all existed
42*5 210 0 2,1 existed
42*6 252 5 2 existed
42*7 294 9 2,4 existed
42*8 336 3 6 existed
42*9 378 7 3,8 existed
```

Looking at the above table under `digits`

column you can find all the digits from “ to `9`

, Hence it required `9`

multiples of `42`

to get all the digits. So the depth of `42`

is `9`

. Write a function named `computeDepth`

which computes the depth of its integer argument. Only positive numbers greater than zero will be passed as an input.

## The solution in Python code

Option 1:

```
def compute_depth(n):
i = 0
digits = set()
while len(digits) < 10:
i += 1
digits.update(str(n * i))
return i
```

Option 2:

```
def compute_depth(n):
s, i = set(str(n)), 1
while len(s) < 10:
i += 1
s |= set(str(n*i))
return i
```

Option 3:

```
from itertools import count
def compute_depth(n):
found = set()
update = found.update
return next(i for i,x in enumerate(count(n, n), 1) if update(str(x)) or len(found) == 10)
```

## Test cases to validate our solution

```
test.it("Basic tests")
test.assert_equals(compute_depth(1),10)
test.assert_equals(compute_depth(42),9)
```