Comparing Arrays using LINQ in C#

Question

hi,

i've two arrays like

        string[] a = { "a", "b", "c" };
        string[] b = { "a", "b", "c" };

i need to compare the two arrays using linq.

the comparision should take place only if both arrays have same size

Answer 1

string[] a = { "a", "b" };
string[] b = { "a", "b" };

return (a.Length == b.Length && a.Intersect(b).Count() == a.Length);

---

After some performance testing:

• Over 10,000 small strings - 5ms
• Over 100,000 small strings - 99ms
• Over 1,000,000 small strings - Avg. 601ms
• Over 100,000 ~500 character strings - 190ms

Answer 2

Not sure about the performance, but this seems to work.

string[] a = { "a", "b", "c" };
string[] b = { "a", "b", "c" };

bool result = a.SequenceEqual(b);
Assert.AreEqual(true, result);

However, it is not order independent so it does not fulfill the OP's requirement.

string[] a = { "a", "b", "c" };
string[] b = { "a", "c", "b" };

bool result = a.SequenceEqual(b);
Assert.AreEqual(false, result);

Answer 3

if order doesn't matter or there can be duplicates, then perhaps:

public static class IEnumerableExtensions
{
    public static bool HasSameContentsAs<T>(this ICollection<T> source,
                                            ICollection<T> other)
    {
        if (source.Count != other.Count)
        {
            return false;
        }
        var s = source
            .GroupBy(x => x)
            .ToDictionary(x => x.Key, x => x.Count());
        var o = other
            .GroupBy(x => x)
            .ToDictionary(x => x.Key, x => x.Count());
        int count;
        return s.Count == o.Count &&
               s.All(x => o.TryGetValue(x.Key, out count) &&
                          count == x.Value);
    }
}

usage:

string[] a = { "a", "b", "c" };
string[] b = { "c", "a", "b" };

bool containSame = a.HasSameContentsAs(b);

some use cases:

• different lengths (expect false)

  string[] a = { "a", "b", "c" };
  string[] b = { "b", "c" };
  

• different order (expect true)

  string[] a = { "a", "b", "c" };
  string[] b = { "b", "c", "a" };
  

also works if the inputs can contain duplicate items, though it isn't clear from the question whether that characteristic is desired or not, consider:

• duplicated items have same count (expect true)

  string[] a = { "a", "b", "b", "c" };
  string[] b = { "a", "b", "c", "b" };
  

• duplicated items with different counts (expect false)

  string[] a = { "a", "b", "b", "b", "c" };
  string[] b = { "a", "b", "c", "b", "c" };
  

Answer 4

I think this will always be an O(n log n) operation, so I'd just sort both arrays and compare them e.g. using SequenceEqual.