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)

Source: codewars | Difficulty: EASY
Tags: Fundamentals

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

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