Intersect can be used to find matches between two collections, like so:
// Assign two arrays.
int[] array1 = { 1, 2, 3 };
int[] array2 = { 2, 3, 4 };
// Call Intersect extension method.
var intersect = array1.Intersect(array2);
// Write intersection to screen.
foreach (int value in intersect)
{
Console.WriteLine(value); // Output: 2, 3
}
However what I'd like to achieve is the opposite, I'd like to list items from one collection that are missing from the other:
// Assign two arrays.
int[] array1 = { 1, 2, 3 };
int[] array2 = { 2, 3, 4 };
// Call "NonIntersect" extension method.
var intersect = array1.NonIntersect(array2); // I've made up the NonIntersect method
// Write intersection to screen.
foreach (int value in intersect)
{
Console.WriteLine(value); // Output: 4
}
This question is related to
c#
.net
collections
intersect
This code enumerates each sequence only once and uses Select(x => x)
to hide the result to get a clean Linq-style extension method. Since it uses HashSet<T>
its runtime is O(n + m)
if the hashes are well distributed. Duplicate elements in either list are omitted.
public static IEnumerable<T> SymmetricExcept<T>(this IEnumerable<T> seq1,
IEnumerable<T> seq2)
{
HashSet<T> hashSet = new HashSet<T>(seq1);
hashSet.SymmetricExceptWith(seq2);
return hashSet.Select(x => x);
}
/// <summary>
/// Given two list, compare and extract differences
/// http://stackoverflow.com/questions/5620266/the-opposite-of-intersect
/// </summary>
public class CompareList
{
/// <summary>
/// Returns list of items that are in initial but not in final list.
/// </summary>
/// <param name="listA"></param>
/// <param name="listB"></param>
/// <returns></returns>
public static IEnumerable<string> NonIntersect(
List<string> initial, List<string> final)
{
//subtracts the content of initial from final
//assumes that final.length < initial.length
return initial.Except(final);
}
/// <summary>
/// Returns the symmetric difference between the two list.
/// http://en.wikipedia.org/wiki/Symmetric_difference
/// </summary>
/// <param name="initial"></param>
/// <param name="final"></param>
/// <returns></returns>
public static IEnumerable<string> SymmetricDifference(
List<string> initial, List<string> final)
{
IEnumerable<string> setA = NonIntersect(final, initial);
IEnumerable<string> setB = NonIntersect(initial, final);
// sum and return the two set.
return setA.Concat(setB);
}
}
I think you might be looking for Except
:
The Except operator produces the set difference between two sequences. It will only return elements in the first sequence that don't appear in the second. You can optionally provide your own equality comparison function.
Check out this link, this link, or Google, for more information.
string left = "411329_SOFT_MAC_GREEN";
string right= "SOFT_MAC_GREEN";
string[] l = left.Split('_');
string[] r = right.Split('_');
string[] distinctLeft = l.Distinct().ToArray();
string[] distinctRight = r.Distinct().ToArray();
var commonWord = l.Except(r, StringComparer.OrdinalIgnoreCase)
string result = String.Join("_",commonWord);
result = "411329"
I'm not 100% sure what your NonIntersect method is supposed to do (regarding set theory) - is it
B \ A (everything from B that does not occur in A)?
If yes, then you should be able to use the Except operation (B.Except(A)).
You can use
a.Except(b).Union(b.Except(a));
Or you can use
var difference = new HashSet(a);
difference.SymmetricExceptWith(b);
array1.NonIntersect(array2);
Nonintersect such operator is not present in Linq you should do
except -> union -> except
a.except(b).union(b.Except(a));
Source: Stackoverflow.com