如何在C#中消除二维数组中的重复项

Question

just started to learn programming and I need 2D array without duplicates. This code (well edited for 1D) worked just fine for 1D but doesn't for 2D and have no clue why. Would be very happy if someone helped me. Thanks.

        Random r = new Random();
        int[,] array = new int[10, 8];

        for (int i = 0; i < array.GetLength(0); i++)
        {
            for (int j = 0; j < array.GetLength(1); j++)
            {
                array[i, j] = r.Next(10, 100);
                for (int k = 0; k < i; k++)
                {
                    for (int l = 0; l < j; l++)
                    {
                        if (array[i,j] == array[k,l])
                        {
                            i--;
                            j--;
                            break;
                        }
                    }
                }
            }
        }

Answer 1

With the nested j loop you are filling the entire second dimension for each i , but in the k and l loops you are only checking the grid to the upper and left of current cell. You could place a number twice because you are not checking every previously filled location.

If we change the code to this:

        for (int k = 0; k < array.GetLength(0); k++)
        {
            for (int l = 0; l < array.GetLength(1); l++)
            {
                if (i != k && j != l && array[i, j] == array[k, l])
                {
                    i--;
                    j--;
                    break;
                }
            }
        }

Then you eliminate that problem, but you very quickly find that you get a IndexOutOfRangeException because you're decrementing both i & j at the same time. That's not moving you to the previous value - it's jumping back a whole row and left one cell - and that's ultimately sending i or j to -1 and that's not good.

If you want to do it like you're attempting then you need to have a way to simply move back to the previously filled cell, regardless of the row or column you're on.

Try this:

for (int x = 0; x < array.GetLength(0) * array.GetLength(1); x++)
{
    array[x % array.GetLength(0), x / array.GetLength(0)] = r.Next(10, 100);
    for (int y = 0; y < x; y++)
    {
        if (array[x % array.GetLength(0), x / array.GetLength(0)] == array[y % array.GetLength(0), y / array.GetLength(0)])
        {
            x--;
            break;
        };
    }
}

However, that's not very efficient. Try this instead:

var values = Enumerable.Range(10, 90).OrderBy(_ => r.Next()).ToArray();

for (int x = 0; x < array.GetLength(0) * array.GetLength(1); x++)
{
    array[x % array.GetLength(0), x / array.GetLength(0)] = values[x];
}

Answer 2

So, first of all, that just seems inefficient. Not sure why you want to do it this way, but then again, don't know the reason. Looks like a programming assignment.

My guess, you need a sort of double break going on. When you break finding a match, you don't break out to the "k" for loop, so you continue looking for a match even though you found one. Try setting a boolean value to say it's found, then use that in the criteria for the for loop for k. That'll break it out and let you start over on the outside loops for i and j.

Even then, it won't work because you indescriminately subtracted i and j. So if you're on position 1,2 you will jump back to 0,1 rather than 1,2. So you need to subtract j, if it drops below 0, then subtract from i and add "array.GetLength(1)" to j.

Answer 3

This solution depends on HashSet 's property of containing unique elements. It has an Add method that returns false when we try to add existing elements.

Random r = new Random();
int[,] array = new int[10, 8];
var usedValues = new HashSet<int>();

for (int i = 0; i < array.GetLength(0); i++)
{
    for (int j = 0; j < array.GetLength(1); j++)
    {
        int uniqueValue;
        while (true)
        {
            uniqueValue = r.Next(10, 100);
            if (usedValues.Add(uniqueValue)) break; // It is unique indeed
            // It is not unique, try again.
        }
        array[i, j] = uniqueValue;
    }
}

The above solution is more suitable when the range of the acceptable unique values is large. In this specific case the range is very small (10-99), and the solution offered by @Enigmativity is preferable.