Write
```python
smaller(arr)
```
that given an array ```arr```, you have to return the amount of numbers that are smaller than ```arr[i]``` to the right.

For example:
```python
smaller([5, 4, 3, 2, 1]) == [4, 3, 2, 1, 0]
smaller([1, 2, 0]) == [1, 1, 0]
```
``` haskell
smaller [5,4,3,2,1]  `shouldBe` [4,3,2,1,0]
smaller [1,2,3]      `shouldBe` [0,0,0]
smaller [1, 2, 0]    `shouldBe` [1, 1, 0]
```
If you've completed this one and you feel like testing your performance tuning of this same kata, head over to the much tougher version How many are smaller than me II?

Difficulty: introductory

Starter code:

def smaller(arr):
	

Solutions:
def smaller(arr):
    # Good Luck!
    return [len([a for a in arr[i:] if a < arr[i]]) for i in range(0, len(arr))]


def smaller(arr):
    return [sum(b < a for b in arr[i + 1:]) for i, a in enumerate(arr)]


def smaller(arr):
    return [sum(x > y for y in arr[i+1:]) for i, x in enumerate(arr)]

def smaller(arr):
    return [sum(j < v for j in arr[i:]) for i, v in enumerate(arr)]

def smaller(arr):
    a = []
    counter = 0
    for j in range(len(arr)):
        j = arr[0]
        for k in arr:
            if j > k:
                counter += 1
        a.append(counter)
        counter = 0
        arr.remove(arr[0])
    return(a)


def smaller(arr):
    return [sum(1 for right in arr[i+1:] if right<item) for i,item in enumerate(arr)]

def smaller(nums):
    i = 0; res = []
    while i < len(nums):
        j = i + 1; nb = 0
        while j < len(nums):
            if nums[i] > nums[j]:
                nb += 1
            j += 1
        res.append(nb)
        i += 1
    return res

# modified merge sort counting left > right cases
def countsort(arr, cntarr, cntdict):
    if len(arr) > 1:
        mid = len(arr) // 2
        left = arr[:mid]
        leftcount = cntarr[:mid]
        right = arr[mid:]
        rightcount = cntarr[mid:]
         
        countsort(left, leftcount, cntdict)
        countsort(right, rightcount, cntdict)
        
        i = 0
        j = 0
        k = 0
        while( i < len(left) and j < len(right) ):
            if left[i] > right[j]:
                arr[k] = right[j]
                
                # increase count of smaller elem
                for n in range(i, len(left)):
                    temp = leftcount[n]
                    cntdict[temp] = cntdict[temp] + 1
                
                # updates position of indices wrt original position 
                cntarr[k] = rightcount[j]
                j = j + 1
            else:
                arr[k] = left[i]
                cntarr[k] = leftcount[i]
                i = i + 1

            k = k + 1

        while i < len(left):
            arr[k] = left[i]
            cntarr[k] = leftcount[i]
            i = i + 1
            k = k + 1

        while j < len(right):
            arr[k] = right[j]
            cntarr[k] = rightcount[j]
            j = j + 1
            k = k + 1
            
def smaller(arr):
    # list of relative position of original list
    posarr = [i for i in range(len(arr))]

    # dictionary of counts of smaller elem
    cntdict = {i:0 for i in range(len(arr))}

    # sorts arr and keeps count of smaller elem actions 
    countsort(arr, posarr, cntdict)   

    soln = []
    for i in range(len(arr)):
        soln.append(cntdict[i])

    return soln