There are some candies that need to be distributed to some children as fairly as possible (i.e. the variance of result needs to be as small as possible), but I don't know how to distribute them, so I need your help. Your assignment is to write a function with signature `distribute(m, n)` in which `m` represents how many candies there are, while `n` represents how many children there are. The function should return a container which includes the number of candies each child gains.

# Notice
1. *The candy can't be divided into pieces.*
2. The list's order doesn't matter.

# Requirements
1. The case `m < 0` is equivalent to `m == 0`.
2. If `n <= 0` the function should return an empty container. 
3. If there isn't enough candy to distribute, you should fill the corresponding number with `0`.

# Examples
```python
distribute(-5,  0) # should be [] 
distribute( 0,  0) # should be [] 
distribute( 5,  0) # should be [] 
distribute(10,  0) # should be [] 
distribute(15,  0) # should be [] 
distribute(-5, -5) # should be [] 
distribute( 0, -5) # should be [] 
distribute( 5, -5) # should be [] 
distribute(10, -5) # should be [] 
distribute(15, -5) # should be []
distribute(-5, 10) # should be [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
distribute( 0, 10) # should be [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
distribute( 5, 10) # should be [1, 1, 1, 1, 1, 0, 0, 0, 0, 0]
distribute(10, 10) # should be [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
distribute(15, 10) # should be [2, 2, 2, 2, 2, 1, 1, 1, 1, 1]
```
  
# Input
  1. m: Integer (m <= 100000)
  2. n: Integer (n <= 1000)

# Output
  1. [Integer]

Difficulty: EASY
Starter code: def distribute(m, n):
	

Solutions:
def distribute(m, n):
	if n <= 0:
		return []
	(q, r) = divmod(max(m, 0), n)
	return [q + (i < r) for i in range(n)]


def distribute(m, n):
	lst = []
	if n > 0:
		lst = [0 for i in range(n)]
		if m > 0:
			for j in range(m):
				lst[j % n] += 1
	return lst


def distribute(m, n):
	m = max(0, m)
	return [m // n + (m % n > i) for i in range(n)]


def distribute(m, n):
	if n <= 0:
		return []
	(d, r) = divmod(max(m, 0), n)
	return r * [d + 1] + (n - r) * [d]


def distribute(m, n):
	if m <= 0:
		return [0] * n
	elif n <= 0:
		return []
	else:
		(a, b) = divmod(m, n)
		return [a] * n if b == 0 else [a + 1] * b + [a] * (n - b)


def distribute(m, n):
	list = []
	if n <= 0:
		list = []
	elif m <= 0:
		for i in range(n):
			list.append(0)
	else:
		number = int(m / n)
		mod = m % n
		for i in range(mod):
			list.append(number + 1)
		for j in range(mod, n):
			list.append(number)
	return list


def distribute(m, n):
	if m <= 0:
		return [0] * n
	if n <= 0:
		return []
	else:
		lst = [0] * n
		x = m // n
		y = m % n
		while x > 0:
			for i in range(n):
				lst[i] += 1
			x -= 1
		if y > 0:
			for j in range(y):
				lst[j] += 1
		return lst


def distribute(m, n):
	if n <= 0:
		return []
	if m < 0:
		m = 0
	(q, r) = divmod(m, n)
	return [q + 1] * r + [q] * (n - r)


def distribute(m, n):
	if m < 0:
		m = 0
	if n <= 0:
		return []
	minCandiesPerPerson = m // n
	rest = m - n * minCandiesPerPerson
	return [minCandiesPerPerson] * (n - rest) + [minCandiesPerPerson + 1] * rest