I'm wondering if anyone knows a better (as in faster) algorithm/solution to solve my problem:

In my program I have an array of uints, from which I want to remove the entries contained in another uint array. However, I cannot use the union of the sets, because I need to keep duplicate values. Badly worded explaination, but the example should make it a bit clearer:

```
    uint[] array_1 = new uint[7] { 1, 1, 1, 2, 3, 4, 4};
    uint[] array_2 = new uint[4] { 1, 2, 3, 4 };

    uint[] result = array_1 .RemoveRange(array_2);
    // result should be: { 1, 1, 4 }

```

This is my current best idea; but it's fairly slow:

```
    public static uint[] RemoveRange(this uint[] source_array, uint[] entries_to_remove)
    {
        int current_source_length = source_array.Length;
        for (int i = 0; i < entries_to_remove.Length; i++)
        {
            for (int j = 0; j < current_source_length; j++)
            {
                if (entries_to_remove[i] == source_array[j])
                {
                    // Shifts the entries in the source_array.
                    Buffer.BlockCopy(source_array, (j + 1)* 4 , source_array, j * 4, (current_source_length - j) * 4);
                    current_source_length--;
                    break;
                }
            }
        }
        uint[] new_array = new uint[current_source_length];
        Buffer.BlockCopy(source_array, 0, new_array, 0, current_source_length * 4);
        return new_array;
    }

```

So again, can someone come up with a more clever approach to achieve what I want?

Thanks!