In this Kata, you will be given two integers `n` and `k` and your task is to remove `k-digits` from `n` and return the lowest number possible, without changing the order of the digits in `n`. Return the result as a string.

Let's take an example of `solve(123056,4)`. We need to remove `4` digits from `123056` and return the lowest possible number. The best digits to remove are `(1,2,3,6)` so that the remaining digits are `'05'`. Therefore, `solve(123056,4) = '05'`. 

Note also that the order of the numbers in `n` does not change: `solve(1284569,2) = '12456',` because we have removed `8` and `9`. 

More examples in the test cases.

Good luck!

Difficulty: EASY
Starter code: def solve(n, k):
	

Solutions:
from itertools import combinations

def solve(n, k):
	return ''.join(min(combinations(str(n), len(str(n)) - k)))


from itertools import combinations

def solve(n, k):
	return min((''.join(c) for c in combinations(str(n), len(str(n)) - k)), key=int)


from itertools import combinations as c

def solve(n, k):
	b = len(str(n)) - k
	l = [''.join(i) for i in c(str(n), b)]
	return min(l)


def solve(n, k):
	s = str(n)
	for _ in range(k):
		i = next((i for i in range(len(s)) if i == len(s) - 1 or s[i] > s[i + 1]))
		s = s[:i] + s[i + 1:]
	return s


def solve(n, k):
	s = str(n)
	result = ''
	for _ in range(len(s) - k):
		i = min(range(k + 1), key=s.__getitem__)
		result += s[i]
		k -= i
		s = s[i + 1:]
	return result


from itertools import combinations

def solve(n, k):
	s = str(n)
	return ''.join(min((xs for xs in combinations(s, len(s) - k))))


def solve(n, k):
	n = str(n)
	number = ''
	while k < len(n):
		m = min([(int(n[i]), i) for i in range(k + 1)])
		number += str(m[0])
		n = n[m[1] + 1:]
		k -= m[1]
	return number


def solve(n, k):
	s = str(n)
	Slen = len(s)
	removed = False
	largestIndex = 0
	if Slen < 2 and k > 1 or k > Slen:
		return '0'
	i = 1
	for j in range(k):
		while i < len(s):
			if s[i] < s[i - 1]:
				s = s[:i - 1] + s[i:]
				removed = True
				break
			i += 1
		i = 1
		if not removed:
			largestIndex = 0
			j = 0
			while not removed and j < len(s):
				if int(s[j]) > int(s[largestIndex]):
					largestIndex = j
				j += 1
			s = s[:j - 1] + s[j:]
		removed = False
	return s


def solve(n, k):
	s = ''
	for i in str(n):
		if k == 0:
			s += i
		else:
			while s and s[-1] > i and k:
				k -= 1
				s = s[:-1]
			s += i
			p = i
	return s[:-k] if k else s