Каков наилучший способ группировки группировок?

Question

Так что недавно я столкнулся с проблемой, мне и моей команде нужно взять список объектов и сгруппировать их по условиям, затем эту группу по большему количеству условий, затем эту группу по еще большему количеству условий и так далее для 7 илиитак уровни. Подумав об этом в течение нескольких дней, я наконец-то придумал что-то вроде древовидной структуры, хотя каждый уровень определяется вручную (в основном для удобства чтения, потому что как только он запрограммирован, он будет установлен в камне). Каков наилучший метод для этого и, если возможно, почему? Вот что у меня есть, используя список случайных целых чисел. Проверки: делятся на 2, делятся на 3 и делятся на 5 в этом порядке (хотя порядок условий не имеет значения для требований):

Вот код для случайного списка целых чисел плюскласс TopNode

Random rand = new Random();
List<int> ints = new List<int>();
for (int i = 0; i < 10; i++)
{
   ints.Add(rand.Next(0, 10000001));
}

TopNode node = new TopNode(ints);

Вот остаток кода для класса верхнего узла

public class TopNode 
{ 
    public Even Even { get; set; }
    public Odd Odd { get; set; }
    public TopNode(List<int> ints)
    {
        var even = ints.Where(x => x % 2 == 0).ToList();
        var odd = ints.Where(x => x % 2 != 0).ToList();
        if (even.Count > 0)
        {
            Even = new Even(even);
        }
        if (odd.Count > 0)
        {
            Odd = new Odd(odd);
        }
    }
} 

public class Even {
    public Mulitple3 Mulitple3 { get; set; }
    public NotMulitple3 NotMulitple3 { get; set; }
    public Even(List<int> ints)
    {
        var multiple = ints.Where(x => x % 3 == 0).ToList();
        var not = ints.Where(x => x % 3 != 0).ToList();
        if (multiple.Count > 0)
        {
            Mulitple3 = new Mulitple3(multiple);
        }
        if (not.Count > 0)
        {
            NotMulitple3 = new NotMulitple3(not);
        }
    }
} 

public class Odd {
    public Mulitple3 Mulitple3 { get; set; }
    public NotMulitple3 NotMulitple3 { get; set; }
    public Odd(List<int> ints)
    {
        var multiple = ints.Where(x => x % 3 == 0).ToList();
        var not = ints.Where(x => x % 3 != 0).ToList();
        if (multiple.Count > 0)
        {
            Mulitple3 = new Mulitple3(multiple);
        }
        if (not.Count > 0)
        {
            NotMulitple3 = new NotMulitple3(not);
        }
    }
}

public class Mulitple3
{
    public Multiple5 Multiple5 { get; set; }
    public NotMultiple5 NotMultiple5 { get; set; }
    public Mulitple3(List<int> ints)
    {
        var multiple = ints.Where(x => x % 5 == 0).ToList();
        var not = ints.Where(x => x % 5 != 0).ToList();
        if (multiple.Count > 0)
        {
            Multiple5 = new Multiple5(multiple);
        }
        if (not.Count > 0)
        {
            NotMultiple5 = new NotMultiple5(not);
        }
    }
}

public class NotMulitple3
{
    public Multiple5 Multiple5 { get; set; }
    public NotMultiple5 NotMultiple5 { get; set; }
    public NotMulitple3(List<int> ints)
    {
        var multiple = ints.Where(x => x % 5 == 0).ToList();
        var not = ints.Where(x => x % 5 != 0).ToList();
        if (multiple.Count > 0)
        {
            Multiple5 = new Multiple5(multiple);
        }
        if (not.Count > 0)
        {
            NotMultiple5 = new NotMultiple5(not);
        }
    }
}

public class Multiple5
{
    public List<int> ints { get; set; }
    public Multiple5(List<int> ints)
    {
        this.ints = ints;
    }
}

public class NotMultiple5
{
    public List<int> ints { get; set; }
    public NotMultiple5(List<int> ints)
    {
        this.ints = ints;
    }
}

Answer 1

Самое простое дерево - это просто IEnumerable<IEnumerable<...>>, и вы можете сформировать его, используя GroupBy.

Вот простой пример, который группирует некоторые целые числа в дерево на основе делимости на 2, 3 и 5. отпечатки:

{{{{1,7,23,29},{5}},{{3,9,87,21}}},{{{4,8,34,56}},{{78},{30}}}}

.

public static void Main()
{
    int[] input = new int[]{1, 3, 4, 5, 7, 8, 9, 23, 34, 56, 78, 87, 29, 21, 2*3*5};

    // TREE
    var groupedTree = input.GroupBy(x => x % 2 == 0)
        .Select(g => g.GroupBy(x => x % 3 == 0)
        .Select(h => h.GroupBy(x => x % 5 == 0)));

    Console.WriteLine(Display(groupedTree));
}

// Hack code to dump the tree
public static string DisplaySequence(IEnumerable items) => "{" + string.Join(",", items.Cast<object>().Select(x => Display(x))) + "}";
public static string Display(object item) => item is IEnumerable seq ? DisplaySequence(seq) : item.ToString();

Answer 2

Ответы NetMage и Theodor были именно тем, что я искал в соответствии с вопросом. Тем не менее, из-за чрезмерного места в моем примере кода, я не упомянул, что иногда ответ будет возвращаться с большим, чем просто истина или ложь, и вместо этого будет возвращать 3 или 4 значения (а в очень редких случаях одно из возвращаемых значений должно бытьсгруппированы и перебраны). Это не является их собственной ошибкой, и их работа на самом деле очень хорошая и полезна, но с моей стороны это было слишком много. В связи с этим я решил воспользоваться ответами Яна и Кайлса, основываясь на комментариях, и придумал следующее:

Хотя он не идеален, он позволяет мне возвращать столько значений, сколько я хочу, сгруппировать поесли мне нужно (определено в операторах case), и если мне нужно только фильтровать по 2, а не по всем 3, или нужно изменить порядок, я могу добавить их в массив условий по мере необходимости.

Еще раз спасибо за помощь, и я извиняюсь, я не был достаточно ясен в вопросе.

Random rand = new Random();
List<int> ints = new List<int>();
for (int i = 0; i < 10000000; i++)
{
   ints.Add(rand.Next(0, 10000001));
}
string[] conditions = new string[] { "even", "div3", "div5" };
var dynamicSort = new Sorted(ints);

public class Sorted
{
    public List<List<int>> returnVal { get; set; }
    public static List<int> Odd(List<int> ints)
    {
        return ints.Where(x => x % 2 != 0).ToList();
    }
    public static List<int> Even(List<int> ints)
    {
        return ints.Where(x => x % 2 == 0).ToList();
    }
    public static List<int> DivThree(List<int> ints)
    {
        return ints.Where(x => x % 3 == 0).ToList();
    }
    public static List<int> NotDivThree(List<int> ints)
    {
        return ints.Where(x => x % 3 != 0).ToList();
    }
    public static List<int> DivFive(List<int> ints)
    {
        return ints.Where(x => x % 5 == 0).ToList();
    }
    public static List<int> NotDivFive(List<int> ints)
    {
        return ints.Where(x => x % 5 != 0).ToList();
    }

    public Sorted(List<int> ints, string[] conditions)
    {
        returnVal = GetSorted(ints, conditions, 0);
    }
    public List<List<int>> GetSorted(List<int>ints, string[] conditions, int index)
    {
        var sortReturn = new List<List<int>>();
        switch (conditions[index].ToLower()) 
        {
            case "even":
            case "odd":
                {
                    if (index == conditions.Length - 1)
                    {
                        sortReturn.Add(Odd(ints));
                        sortReturn.Add(Even(ints));
                    }
                    else
                    {
                        var i = ++index;
                        sortReturn.AddRange(GetSorted(Odd(ints), conditions, i));
                        sortReturn.AddRange(GetSorted(Even(ints), conditions, i));
                    }
                    break;
                }
            case "div3":
            case "notdiv3":
                {
                    if (index == conditions.Length - 1)
                    {
                        sortReturn.Add(DivThree(ints));
                        sortReturn.Add(NotDivThree(ints));
                    }
                    else
                    {
                        var i = ++index;
                        sortReturn.AddRange(GetSorted(DivThree(ints), conditions, i));
                        sortReturn.AddRange(GetSorted(NotDivThree(ints), conditions, i));
                    }
                    break;
                }
            case "div5":
            case "notdiv5":
                {
                    if (index == conditions.Length - 1)
                    {
                        sortReturn.Add(DivFive(ints));
                        sortReturn.Add(NotDivFive(ints));
                    }
                    else
                    {
                        var i = ++index;
                        sortReturn.AddRange(GetSorted(DivFive(ints), conditions, i));
                        sortReturn.AddRange(GetSorted(NotDivFive(ints), conditions, i));
                    }
                    break;
                }
        }
        return sortReturn;
    }
}

Answer 3

Я предлагаю создать класс коллекции, который сможет фильтровать ваши объекты и возвращать экземпляры самого себя, чтобы фильтрация могла продолжаться глубже. Например, давайте предположим, что ваши объекты имеют тип MyObject:

class MyObject
{
    public int Number { get; }
    public MyObject(int number) => this.Number = number;
    public override string ToString() => this.Number.ToString();
}

Вот пример коллекции фильтров MyCollection, которая поддерживает фильтрацию для Odd, Even, Multiple3и NonMultiple3. Необходимые поиски создаются лениво , чтобы избежать выделения памяти для запросов, которые никогда не будут запрашиваться:

class MyCollection : IEnumerable<MyObject>
{
    private readonly IEnumerable<MyObject> _source;

    private readonly Lazy<ILookup<bool, MyObject>> _multiple2Lookup;
    private readonly Lazy<MyCollection> _even;
    private readonly Lazy<MyCollection> _odd;

    private readonly Lazy<ILookup<bool, MyObject>> _multiple3Lookup;
    private readonly Lazy<MyCollection> _multiple3;
    private readonly Lazy<MyCollection> _nonMultiple3;

    public MyCollection Even => _even.Value;
    public MyCollection Odd => _odd.Value;

    public MyCollection Multiple3 => _multiple3.Value;
    public MyCollection NonMultiple3 => _nonMultiple3.Value;

    public MyCollection(IEnumerable<MyObject> source)
    {
        _source = source;

        _multiple2Lookup = new Lazy<ILookup<bool, MyObject>>(
            () => _source.ToLookup(o => o.Number % 2 == 0));
        _even = new Lazy<MyCollection>(
            () => new MyCollection(_multiple2Lookup.Value[true]));
        _odd = new Lazy<MyCollection>(
            () => new MyCollection(_multiple2Lookup.Value[false]));

        _multiple3Lookup = new Lazy<ILookup<bool, MyObject>>(
            () => _source.ToLookup(o => o.Number % 3 == 0));
        _multiple3 = new Lazy<MyCollection>(
            () => new MyCollection(_multiple3Lookup.Value[true]));
        _nonMultiple3 = new Lazy<MyCollection>(
            () => new MyCollection(_multiple3Lookup.Value[false]));
    }

    public IEnumerator<MyObject> GetEnumerator() => _source.GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

Пример использования:

var source = Enumerable.Range(1, 20).Select(i => new MyObject(i));
var myObjects = new MyCollection(source);
var filtered = myObjects.Even.NonMultiple3;
Console.WriteLine(String.Join(", ", filtered));

Вывод:

2, 4, 8, 10, 14, 16, 20

Возможным недостатком этого подхода является то, что он позволяет вызывать оба myObjects.Even.NonMultiple3и myObjects.NonMultiple3.Even. Оба запроса возвращают одинаковые результаты, но вызывают создание избыточных поисков.

Answer 4

Я также создал класс дерева, но я использовал класс для хранения каждого условия и массив условий для обработки группировки. Ожидается, что каждое условие вернет int для создания группировки. Затем класс дерева может пройти через условия, чтобы сгруппировать каждый уровень. Чтобы сделать дерево единообразным, я держал список членов на каждом уровне, который затем делится на следующий уровень.

public class Condition<T> {
    public string[] Values;
    public Func<T, int> Test;

    public Condition(string[] values, Func<T, int> test) {
        Values = values;
        Test = test;
    }
}

public class Level {
    public static Level<T> MakeTree<T>(IEnumerable<T> src, Condition<T>[] conditions) => new Level<T>(src, conditions);
    public static IEnumerable<int> MakeKey<T>(Condition<T>[] conditions, params string[] values) {
        for (int depth = 0; depth < values.Length; ++depth)
            yield return conditions[depth].Values.IndexOf(values[depth]);
    }
}

public class Level<T> {
    public string Value;
    public Level<T>[] NextLevels;
    public List<T> Members;

    public Level(string value, List<T> members) {
        Value = value;
        Members = members;
        NextLevels = null;
    }

    public Level(IEnumerable<T> src, Condition<T>[] conditions) : this("ALL", src.ToList()) => GroupOneLevel(this, 0, conditions);

    public void GroupOneLevel(Level<T> parent, int depth, Condition<T>[] conditions) {
        var condition = conditions[depth];
        var nextLevels = new Level<T>[condition.Values.Length];
        for (int j2 = 0; j2 < condition.Values.Length; ++j2) {
            nextLevels[j2] = new Level<T>(condition.Values[j2], new List<T>());
        }

        for (int j2 = 0; j2 < parent.Members.Count; ++j2) {
            var member = parent.Members[j2];
            nextLevels[condition.Test(member)].Members.Add(member);
        }
        parent.NextLevels = nextLevels;
        if (depth + 1 < conditions.Length)
            for (int j3 = 0; j3 < condition.Values.Length; ++j3)
                GroupOneLevel(nextLevels[j3], depth + 1, conditions);
    }

    public List<T> MembersForKey(IEnumerable<int> values) {
        var curLevel = this;
        foreach (var value in values)
            curLevel = curLevel.NextLevels[value];

        return curLevel.Members;
    }
}

Для вашего примера вы можете использовать это как:

var conditions = new[] {
        new Condition<int>(new[] { "Even", "Odd" }, n => n & 1),
        new Condition<int>(new[] { "Div3", "NOTDiv3" }, n => n % 3 == 0 ? 0 : 1),
        new Condition<int>(new[] { "Div5", "NOTDiv5" }, n => n % 5 == 0 ? 0 : 1)
    };

var ans = Level.MakeTree(ints, conditions);

И вы можете искать определенную часть дерева с помощью:

var evenDiv3 = ans.MembersForKey(Level.MakeKey(conditions, "Even", "Div3"));