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

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 

from itertools import combinations

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