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.

Source: codewars | Difficulty: EASY
Tags: Fundamentals

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