Remove K Digits solution and explanation

def removeKdigits(num: str, k: int) -> str:
    stack = []
    for digit in num:
        while k > 0 and stack and stack[-1] > digit:
            stack.pop()
            k -= 1
        stack.append(digit)
    # If k still > 0, remove the remaining digits from the end
    final_stack = stack[:-k] if k else stack
    # Convert to string and remove leading zeros
    return ''.join(final_stack).lstrip('0') or '0'

import java.util.Stack;

public class Solution {
    public String removeKdigits(String num, int k) {
        Stack<Character> stack = new Stack<>();
        for (char digit : num.toCharArray()) {
            while (k > 0 && !stack.isEmpty() && stack.peek() > digit) {
                stack.pop();
                k--;
            }
            stack.push(digit);
        }
        StringBuilder result = new StringBuilder();
        while (!stack.isEmpty()) {
            result.append(stack.pop());
        }
        result.reverse();
        while (result.length() > 1 && result.charAt(0) == '0') {
            result.deleteCharAt(0);
        }
        return result.length() == 0 ? "0" : result.substring(0, result.length() - k);
    }
}

#include <iostream>
#include <string>
#include <stack>
using namespace std;

string removeKdigits(string num, int k) {
    stack<char> st;
    for (char digit : num) {
        while (k > 0 && !st.empty() && st.top() > digit) {
            st.pop();
            --k;
        }
        st.push(digit);
    }
    string result = "";
    while (!st.empty()) {
        result += st.top();
        st.pop();
    }
    reverse(result.begin(), result.end());
    result = result.substr(0, result.size() - k);
    auto it = result.find_first_not_of('0');
    result = it != string::npos ? result.substr(it) : "0";
    return result;
}

function removeKdigits(num, k) {
    const stack = [];
    for (let digit of num) {
        while (k > 0 && stack.length && stack[stack.length - 1] > digit) {
            stack.pop();
            k--;
        }
        stack.push(digit);
    }
    stack.splice(stack.length - k, k);
    while (stack.length && stack[0] === '0') {
        stack.shift();
    }
    return stack.length ? stack.join('') : '0';
}

#include <stdio.h>
#include <string.h>

char *removeKdigits(char *num, int k) {
    int len = strlen(num);
    // Resultant stack array
    char *stack = (char *)malloc(len + 1);
    int top = -1, toRemove = k;
    for (int i = 0; i < len; i++) {
        char c = num[i];
        while (top >= 0 && stack[top] > c && toRemove > 0) {
            top--;
            toRemove--;
        }
        stack[++top] = c;
    }
    // The final size should be len - k
    top = top - toRemove;
    stack[top + 1] = '\0';
    // Strip leading zeros
    int offset = 0;
    while (stack[offset] == '0') offset++;
    // Check for the 'emptiness' of the string
    if (offset > top) return "0";
    return stack + offset;
}

using System;
using System.Text;

public class Solution {
    public string RemoveKdigits(string num, int k) {
        var stack = new Stack<char>();
        foreach (var digit in num) {
            while (k > 0 && stack.Count > 0 && stack.Peek() > digit) {
                stack.Pop();
                k--;
            }
            stack.Push(digit);
        }
        var result = new StringBuilder();
        foreach (var digit in stack) {
            result.Append(digit);
        }
        result.Length -= k;
        var strResult = new string(result.ToString().Reverse().ToArray());
        return strResult.TrimStart('0') == "" ? "0" : strResult.TrimStart('0');
    }
}

function removeKdigits(num: string, k: number): string {
    const stk: string[] = [];
    for (const c of num) {
        while (k && stk.length > 0 && stk[stk.length - 1] > c) {
            stk.pop();
            k--;
        }
        stk.push(c);
    }
    while (k--) {
        stk.pop();
    }
    return stk.join('').replace(/^0*/g, '') || '0';
}

func removeKdigits(num string, k int) string {
	stk, remain := make([]byte, 0), len(num)-k
	for i := 0; i < len(num); i++ {
		n := len(stk)
		for k > 0 && n > 0 && stk[n-1] > num[i] {
			stk = stk[:n-1]
			n, k = n-1, k-1
		}
		stk = append(stk, num[i])
	}

	for i := 0; i < len(stk) && i < remain; i++ {
		if stk[i] != '0' {
			return string(stk[i:remain])
		}
	}
	return "0"
}