Program to find minimum number in string

Question

I have a c# class like so

internal class QueuedMinimumNumberFinder : ConcurrentQueue<int>
{
    private readonly string _minString;
    public QueuedMinimumNumberFinder(string number, int takeOutAmount)
    {
        if (number.Length < takeOutAmount)
        {
            throw new Exception("Error *");
        }
        var queueIndex = 0;
        var queueAmount = number.Length - takeOutAmount;
        var numQueue = new ConcurrentQueue<int>(number.ToCharArray().Where(m => (int) Char.GetNumericValue(m) != 0).Select(m=>(int)Char.GetNumericValue(m)).OrderBy(m=>m));
        var zeroes = number.Length - numQueue.Count;
        while (queueIndex < queueAmount)
        {
            int next;
            if (queueIndex == 0)
            {
                numQueue.TryDequeue(out next);
                Enqueue(next);
            } else
            {
                if (zeroes > 0)
                {
                    Enqueue(0);
                    zeroes--;
                } else
                {
                    numQueue.TryDequeue(out next);
                    Enqueue(next);
                }
            }
            queueIndex++;
        }
        var builder = new StringBuilder();
        while (Count > 0)
        {
            int next = 0;
            TryDequeue(out next);
            builder.Append(next.ToString());
        }
        _minString = builder.ToString();
    }

    public override string ToString() { return _minString; }
}

The point of the program is to find the minimum possible integer that can be made by taking out any x amount of characters from a string(example 100023 is string, if you take out any 3 letters, the minimum int created would be 100). My question is, is this the correct way to do this? Is there a better data structure that can be used for this problem?

First Edit:

Here's how it looks now

 internal class QueuedMinimumNumberFinder
    {
        private readonly string _minString;
        public QueuedMinimumNumberFinder(string number, int takeOutAmount)
        {
            var queue = new Queue<int>();
            if (number.Length < takeOutAmount)
            {
                throw new Exception("Error *");
            }
            var queueIndex = 0;
            var queueAmount = number.Length - takeOutAmount;
            var numQueue = new List<int>(number.Where(m=>(int)Char.GetNumericValue(m)!=0).Select(m=>(int)Char.GetNumericValue(m))).ToList();
            var zeroes = number.Length - numQueue.Count;
            while (queueIndex < queueAmount)
            {
                if (queueIndex == 0)
                {
                    var nextMin = numQueue.Min();
                    numQueue.Remove(nextMin);
                    queue.Enqueue(nextMin);
                } else
                {
                    if (zeroes > 1)
                    {
                        queue.Enqueue(0);
                        zeroes--;
                    } else
                    {
                        var nextMin = numQueue.Min();
                        numQueue.Remove(nextMin);
                        queue.Enqueue(nextMin);
                    }
                }
                queueIndex++;
            }
            var builder = new StringBuilder();
            while (queue.Count > 0)
            {
                builder.Append(queue.Dequeue().ToString());
            }
            _minString = builder.ToString();
        }

        public override string ToString() { return _minString; }
    }

Answer 1

A pretty simple and efficient implementation can be made, once you realize that your input string digits map to the domain of only 10 possible values: '0' .. '9'.

This can be encoded as the number of occurrences of a specific digit in your input string using a simple array of 10 integers: var digit_count = new int[10];

@MasterGillBates describes this idea in his answer.

You can then regard this array as your priority queue from which you can dequeue the characters you need by iteratively removing the lowest available character (decreasing its occurrence count in the array).

The code sample below provides an example implementation for this idea.

public static class MinNumberSolver
{
    public static string GetMinString(string number, int takeOutAmount)
    {
        // "Add" the string by simply counting digit occurrance frequency.
        var digit_count = new int[10];
        foreach (var c in number)
            if (char.IsDigit(c))
                digit_count[c - '0']++;

        // Now remove them one by one in lowest to highest order.

        // For the first character we skip any potential leading 0s
        var selected = new char[takeOutAmount];
        var start_index = 1;
        selected[0] = TakeLowest(digit_count, ref start_index);

        // For the rest we start in digit order at '0' first.
        start_index = 0;
        for (var i = 0; i < takeOutAmount - 1; i++)
            selected[1 + i] = TakeLowest(digit_count, ref start_index);

        // And return the result.
        return new string(selected);
    }

    private static char TakeLowest(int[] digit_count, ref int start_index)
    {
        for (var i = start_index; i < digit_count.Length; i++)
        {
            if (digit_count[i] > 0)
            {
                start_index = ((--digit_count[i] > 0) ? i : i + 1);
                return (char)('0' + i);
            }
        }
        throw new InvalidDataException("Input string does not have sufficient digits");
    }
}