The Kata was broken—perhaps Codewars server load currently is a lot more than it was 9 months ago when the question was made—but for whatever reason, none of the top 6 solutions could pass within the time constraints imposed on the question. The kata was reworked after someone filed an issue, and now my solution passes. I did write an even more micro optimised version of counting sort which is what I eventually submitted. The only change I made was that since n was 50-100% of the list length it would be faster to find the n smallest elements by counting off the (length - n) largest elements than counting up to n, and since the array had a fixed length for the random tests, we could do that. Here's my final version:

##My Code

count = 0

def performant_smallest(lst, n):
    global count
    count += 1
    c = [0]*101        #Our counter.
    for itm in lst:        c[itm+50] += 1        #Map each number to num+50
    res, sm, stop = [0]*n, 0, (5 - n if count <= 5 else 10000 - n)
    for k in range(100, -1, -1):    #Iterate through the numbers in our counter starting backwards to get even better performance, since `n` is large.
        sm += c[k]
        if sm >= stop:
            c[k] = sm - stop     #The sum of `c[:k+1]` should be equal to `n`, and this would give us the count of the `n` smallest elements.
            break
    sm = 0
    for itm in lst:        #Iterate through the list to present the elements in their appearance order in the list.
        v = itm+50        #The mapping between the list item and its index in our counter.
        if v <= k and c[v] > 0:        #The item is one of the `n` smallest items.
            res[sm] = itm     #Place it in its position in the result list.
            sm += 1
            c[v] -= 1
        if sm == n: break
    return res

The Kata was broken—perhaps Codewars server load currently is a lot more than it was 9 months ago when the question was made—but for whatever reason, none of the top 6 solutions could pass within the time constraints imposed on the question. The kata was reworked after someone filed an issue, and now my solution passes. I did write an even more micro optimised version of counting sort which is what I eventually submitted. The only change I made was that since n was 50-100% of the list length it would be faster to find the n smallest elements by counting off the (length - n) largest elements than counting up to n, and since the array had a fixed length for the random tests, we could do that. Here's my final version:

My Code

count = 0

def performant_smallest(lst, n):
    global count
    count += 1
    c = [0]*101        #Our counter.
    for itm in lst:        c[itm+50] += 1        #Map each number to num+50
    res, sm, stop = [0]*n, 0, (5 - n if count <= 5 else 10000 - n)
    for k in range(100, -1, -1):    #Iterate through the numbers in our counter starting backwards to get even better performance, since `n` is large.
        sm += c[k]
        if sm >= stop:
            c[k] = sm - stop     #The sum of `c[:k+1]` should be equal to `n`, and this would give us the count of the `n` smallest elements.
            break
    sm = 0
    for itm in lst:        #Iterate through the list to present the elements in their appearance order in the list.
        v = itm+50        #The mapping between the list item and its index in our counter.
        if v <= k and c[v] > 0:        #The item is one of the `n` smallest items.
            res[sm] = itm     #Place it in its position in the result list.
            sm += 1
            c[v] -= 1
        if sm == n: break
    return res