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: introductory

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 = []
    else:
        if 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):
    q, r = divmod(max(m, 0), max(n, 1))
    return [q + (i < r) for i in range(max(n, 0))]

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