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

Difficulty: introductory

Starter code:

def compute_depth(n):
	

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

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


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)

def compute_depth(n):
    seen = set()
    for i in range(1, 99999999):
        seen.update(str(n * i))
        if len(seen) == 10:
            return i

from itertools import count
def compute_depth(n):
    res = set(map(str, range(10)))
    for a in count(1):
        res -= set(str(n * a))
        if not res:
            return a

def compute_depth(n):
    digits, depth = set(), 0
    while digits < set('0123456789'):
        depth += 1
        digits.update(str(depth * n))
    return depth

def compute_depth(n):
    digits, depth, num = set('1234567890'), 1, n
    
    while True:
        digits -= set(str(num))
        
        if not digits:
            return depth
        
        num += n
        depth += 1

def compute_depth(n):
    found = set()
    mult = 1
    while not set(x for x in range(0,10)) == found:
        for digit in str(n*mult):
            found.add(int(digit))
        mult += 1
    return mult-1

def compute_depth(n):
    all_digits = [0,1,2,3,4,5,6,7,8,9]
    counter = 1
    while all_digits != []:
        for x in list(map(int,str(n * counter))):
            if x in all_digits:
                all_digits.remove(x)
        counter = counter + 1
    return counter-1

from itertools import count

def compute_depth(n):
    v, target = 0, set("0123456789")
    for x in count(1):
        v += n
        target -= set(str(v))
        if not target: return x