In this Kata, you will be given a lower case string and your task will be to remove `k` characters from that string using the following rule:
```Python
- first remove all letter 'a', followed by letter 'b', then 'c', etc...
- remove the leftmost character first.
```

```Python
For example: 
solve('abracadabra', 1) = 'bracadabra' # remove the leftmost 'a'.
solve('abracadabra', 2) = 'brcadabra'  # remove 2 'a' from the left.
solve('abracadabra', 6) = 'rcdbr'      # remove 5 'a', remove 1 'b' 
solve('abracadabra', 8) = 'rdr'
solve('abracadabra',50) = ''
```

More examples in the test cases. Good luck!

Please also try: 

[Simple time difference](https://www.codewars.com/kata/5b76a34ff71e5de9db0000f2)

[Simple remove duplicates](https://www.codewars.com/kata/5ba38ba180824a86850000f7)

Difficulty: introductory

Starter code:

def solve(st,k):
	

Solutions:
def solve(st,k): 
    for l in sorted(st)[:k]:
        st=st.replace(l,'',1)
    return st

solve = lambda s, k: ''.join(t[1] for t in sorted(sorted(enumerate(s), key=lambda x:x[1])[k:]))

from collections import Counter
from itertools import accumulate
from operator import add
from string import ascii_lowercase

def solve(s, n):
    counter = Counter(s)
    cum_count = [0] + list(accumulate((counter[c] for c in ascii_lowercase), add))
    result = []
    for c in s:
        cum_count[ord(c) - 97] += 1
        if cum_count[ord(c) - 97] > n:
            result.append(c)
    return "".join(result)


from collections import Counter

def solve(letters, removes):
  letter_counts = Counter(letters)
  unique_sorted_letters = sorted(letter_counts.keys())

  for letter in unique_sorted_letters:
    amount_to_remove = letter_counts[letter] if removes >= letter_counts[letter] else removes
    letters = letters.replace(letter, '', amount_to_remove)
    removes -= amount_to_remove

  return letters

import string
def solve(st,k): 
    for c in string.ascii_lowercase:
        count = st.count(c)
        st = st.replace(c,'',k)
        k -= count
        if k <= 0: break
    return st


from collections import defaultdict

# I knew there was a O(n) solution
def solve(st, k):
    D, current, removed = defaultdict(list), ord('a'), set()
    for i,c in enumerate(st): D[ord(c)].append(i)
    while k and len(removed) < len(st):
        removed |= set(D[current][:k])
        k -= min(k, len(D[current]))
        current += 1
    return ''.join(c for i,c in enumerate(st) if i not in removed)

def solve(st,k):     
    for i in range(ord('a'),ord('z')+1):
        while k and chr(i) in st:
                k -= 1
                st = st.replace(chr(i),'',1)
    return st


def solve(st,k):
    if k >= len(st):
        return ""
    chars = sorted(st)
    for ch in chars[:k]:
        st = st.replace(ch, '', 1)
    return st

def solve(s, k): 
    for c in "abcdefghijklmnopqrstuvwxyz":
        n = s.count(c)
        s = s.replace(c, "", k)
        k -= n
        if k < 1:
            break
    return s