Linq扩展集操作

Question

Current situation :

HashSet<string> MasterSet => {100, 3}

HashSet <string> SubSet => {100, 3} or {100} or {100, 3, 1}

So from the huge list of subsets, based on MasterSet I select the particular set like this:

if(MasterSet.SetEquals(subSet) || MasterSet.IsSupersetOf(subSet) || MasterSet.IsSubsetOf(subSet))

Process with that subSet if it is true otherwise loop through other available sets.

Problem with duplicates : If business logic wants to include duplicate in Master set and subset like :

MasterSet => {100, 3, 3}

SubSet => {100, 3, 3} or {100, 3} or {100, 3, 3, 1}

then HashSet usage is deprived.

How do I select the subset if I change the MasterSet and Subset to List<string>

EDIT : Solution provided by "BigYellowCactus" works. However if I wantto use headers instead of order of element to match would it be even easier to filter the set?

MasterSet => {100, 3, 4}
MasterHeaders => {"T","F","V"} //Headers element corresponds to the MasterSet element

Case 1:

SubSet => {3, 100}
SubSetHeaders => {"F", "T"} //Headers element corresponds to the SubSet element

Case 2:

SubSet => {4, 3}
SubSetHeaders => {"V", "F"} //Headers element corresponds to the SubSet element

Is it possible to first match by headers comparing MasterHeaders and SubSetHeaders and then Match by values?

Answer 1

You can use the All extension method.

Description

Determines whether all elements of a sequence satisfy a condition.

---

Example:

if (MasterSet.All(e => SubSet.Contains(e)) || SubSet.All(e => MasterSet.Contains(e)))
{
    //do stuff
}

---

Alternative:

if (!MasterSet.Except(SubSet).Any() || !SubSet.Except(MasterSet).Any())
{
    //do stuff
}

---

Edit:

Just for the case you want to SubSet { 100, 3, 3 } not match MasterSet = { 100, 100, 3 } as Iridium pointed out in his comment, you can go by simple counting the occurring of each element.

if (MasterSet.All(e => MasterSet.Count(r => r==e) <= SubSet.Count(r => r==e))
    || SubSet.All(e => SubSet.Count(r => r==e) <= MasterSet.Count(r => r==e)))
{
    //do stuff
}

(Note that this is probably not the most efficient way...)

---

Edit2:

Given that you basically search a sequence inside a sequence, you can use the following method:

void Main()
{
    var MasterSet = new List<string>() {"100", "3","4"};

    var SubSets = new[] 
    {
        new List<string>() {"100", "100", "3"},
        new List<string>() {"100", "3", "4"},
        new List<string>() {"32", "3423", "4234", "100", "3", "4", "34234"},
        new List<string>() {"100", "32", "3423", "4234", "100", "3", "4", "34234"},
        new List<string>() {"100", "32", "3", "4234", "100", "4", "34234"},
        new List<string>() {"100", "4", "3"},
        new List<string>() {"100", "3", "3"},
        new List<string>() {"100", "3"},
        new List<string>() {"100", "3", "3", "1"}
    };

    foreach (var SubSet in SubSets)
    {
        if (IsMatch(MasterSet, SubSet))
            Console.WriteLine(String.Join(", ", SubSet) + " is a \"subset\"");
        else if (IsMatch(SubSet, MasterSet))
            Console.WriteLine(String.Join(", ", SubSet) + " is a \"superset\"");
    }
}

bool IsMatch<T>(IEnumerable<T> source, IEnumerable<T> to_test)
{
    using (var enumerator = source.GetEnumerator())
    using (var sub_enumerator = to_test.GetEnumerator())
        while (sub_enumerator.MoveNext())
        {
            if (!enumerator.MoveNext())
                return false;
            if (!enumerator.Current.Equals(sub_enumerator.Current))
                sub_enumerator.Reset();
        }
    return true;
}

Output:

100, 3, 4 is a "subset"
32, 3423, 4234, 100, 3, 4, 34234 is a "superset"
100, 32, 3423, 4234, 100, 3, 4, 34234 is a "superset"
100, 3 is a "subset"

Answer 2

The current framework implementations of ISet<T> are HashSet<T> and SortedSet<T> . Both of these classes enforce member uniqueness and do not allow duplicates.

Whilst this may first seem like an omission in the framework, it is actually related to the properties and defenition of a mathematical set. As explained in this post , a mathematical set does not have duplicate members and logicaly {100, 3} is equivalent to {100, 3, 3}.

It may be possible to extend List<T> to implement ISet<T> , perhaps calling the new class Sack<T> but, the non unique implementation of the ISet<T> will be siginificantly more challenging than those exisiting in the framework, without putting much thought into it, it seems reminiscient of general Knapsack problems .