C# match arrays

Question

I have two lists of arrays (arrays contains always pair of int):

List<int[]> a= new List<int[]>
{ 
    new int[2] {0, 1}, 
    new int[2] {5, 3}, 
    new int[2] {1, 3}, 
    new int[2] {5, 0},
};


List<int[]> b= new List<int[]>
{ 
    new int[2] {0, 1}, 
    new int[2] {5, 3},
};

What I would like to get are ids of b list elements in list a.

Is there a better way than looping through list a , checking array elements with if statement and if true add those elements?

Another issue is that condition is true if pair is 0 1 flipped. So 0;1 and 0;1 is true and 0;1 and 1;0 is true;

Answer 1

First, let's say I am absolutely not a math specialist. I just trust Wikipedia :D.

List<int[]> a = new List<int[]>
{
    new int[2] {0, 1},
    new int[2] {5, 3},
    new int[2] {1, 3},
    new int[2] {5, 0},
};

List<int[]> b = new List<int[]>
{
    new int[2] {0, 1},
    new int[2] {5, 3},
};

var aIds = new Dictionary<double, int>(a.Count);

for (int i = 0; i < a.Count; i++)
{
    var pair = a[i];

    // id for (a;b)
    var id1 = 0.5 * (pair[0] + pair[1]) * (pair[0] + pair[1] + 1) + pair[1];
    // id for (b;a)
    var id2 = 0.5 * (pair[1] + pair[0]) * (pair[1] + pair[0] + 1) + pair[0];

    aIds[id1] = i;
    aIds[id2] = i;
}

var intersection = new List<int>();

foreach (var pair in b)
{
    int id;
    if (aIds.TryGetValue(0.5 * (pair[0] + pair[1]) * (pair[0] + pair[1] + 1) + pair[1], out id))
    {
        intersection.Add(id);
    }
}

Reminder from the MSDN:

The T:System.Collections.Generic.Dictionary generic class provides a mapping from a set of keys to a set of values. Each addition to the dictionary consists of a value and its associated key. Retrieving a value by using its key is very fast, close to O(1), because the T:System.Collections.Generic.Dictionary class is implemented as a hash table.

This often a way to get a huge performance gain when dealing with large sets.

If wikipedia said the truth, this should produce a unique identifier for each pair in the dictionary (or two if the order does not matter). Then, you get your solution in O(na) + O(nb) I guess (one loop for the hashing, and another one to find the intersection).

I get this solution from this answer. There is probably some good tips to learn within the thread.

Answer 2

The desired result is a bit difficult to tell from the question; however, apparently the individual arrays (which have exactly two elements each) are considered to be equal if theay have the same entries regardless of sequence. Such a predicate can be implemented in a rather elementary fashion as follows.

Func<int[], int[], bool> ArrayEqual = (x,y) =>
    x.Distinct().OrderBy( z => z ).SequenceEqual( y. Distinct().OrderBy( z => z ) );

The arrays from a which also occur in b (using the notion of equality above) can be determined using Linq as follows.

var Result = a.Where( iA => b.Any( iB => ArrayEqual( iA, iB ) ) );

Edit

If the goal is to reduce the complexity from quadratic time to something better than quadratic time, I suggest to following approach. First, all individual arrays have to be sorted which can be done in linear time in total as each individual array has 2 (which is a constant) number of elements. Next, both a and b have to be sorted lexicographically, which can be done in O( n log n ) time, as again the comparison of two individual arrays can be done in constant time. Next, the desired output can be done using two indices to either list; in each step, it is possible to check in constant time whether two individual arrays are equal or not, which means that an element of a is either accepted or rejected for the output. In each iteration, one of the two indices can be increased; the genration of the output itself can be done in linear time. In total, this yields an O( n log n ) runtime bound.

Answer 3

Some comments

What I would like to get are ids of b list elements in list a.

Nowhere in your question are there IDs mentioned, also not in the data example. I am going to assume you want the indexes (i.e. the position in list a of the matched element.

arrays contains always pair of int

I suggest using a Tuple<int,int>. Which I will use in a code example, for the sake of easier processing. But I'll make it so that you can start off with your initial arrays, in order to maximize compatibility with your code.

Another issue is that condition is true if pair is 0 1 flipped. So 0;1 and 0;1 is true and 0;1 and 1;0 is true;

The solution therefore is to order each element pair (not the list of element itself), so that we match on integer values regardless of their position.

If you need to preserve the order of the numbers (for other purposes), then you'll have to make a copy of the numbers (for the purpose of this matching algorithm), and only sort that copy.

---

The actual question

Is there a better way than looping through list a , checking array elements with if statement and if true add those elements?

Not really. You are going to have to match every element A to every element B.
However, if you are talking about large data sets; you might gain a bit of performance by doing some preprocessing (mainly ordering of entries etc.).

It somewhat depends on what you mean with "a better way". Are you trying to:

• Maximize the speed of processing large data sets?
• Improve the readability of the code?
• Shorten the code itself?

Depending on what your focus is, you will need a different approach. And that is not clear from your question as it is currently phrased.