Сначала я хочу сказать, что я все еще учусь, поэтому мои навыки программирования не очень хороши, и я готов принять любой ваш совет. Во-вторых, я все еще учу английский, поэтому хочу извиниться за неудобства.

Что жмоя проблема это, мне нужна помощь в улучшении моего алгоритма или любой информации о нем, я не знаю, какие слова используют для поиска в этом.

Алгоритм должен находить все комбинации чисел, которые добавляются равными заданному числу. Пример: если у меня есть номер 6, мои результаты должны быть: [1,5], [2,4], [2,2,2], [3,3]

у меня есть следующее:

public List<List<int>> discompose(int number)
    {
        List<List<int>> discomposedPairs = new List<List<int>>();
        if (number <= 3)
            return discomposedPairs;
        int[] numsForCombine = new int[number-1];
        for(int i = 1; i < number;i++){
            numsForCombine[i - 1] = i;
        }
        int ini = 0;
        int end = numsForCombine.Length - 1;
        while (ini <= end)
        {
            List<int> pair = new List<int>();
            pair.Add(numsForCombine[ini++]);
            pair.Add(numsForCombine[end--]);
            discomposedPairs.Add(pair);
        }
        return discomposedPairs;
    }
    public List<List<int>> discomposePair(List<int> pair)
    {
        List<List<int>> parDisc = new List<List<int>>();
        for (int i = 0; i < pair.Count; i++) {
            if (pair[i] > 3)
            {
                List<List<int>> disc = discomposeList(discompose(pair[i]));
                foreach (List<int> item in disc)
                {
                    if (i > 0)
                    {
                        var temp = pair.GetRange(0, i);
                        temp.AddRange(item);
                        parDisc.Add(temp);
                    } else {
                        item.AddRange(pair.GetRange(i+1, pair.Count-(i+1)));
                        parDisc.Add(item);
                    }
                }
            }
        }
        return parDisc;
    }
    public List<List<int>> discomposeList(List<List<int>> list)
    {
        List<List<int>> mainDiscomposedList = new List<List<int>>();
        for (int i = 0; i < list.Count; i++)
        {
            mainDiscomposedList.Add(list[i]);
           List<List<int>> discomposedSubset = discomposePair(list[i]);
            foreach(List<int> item in discomposedSubset){
                mainDiscomposedList.Add(item);
            }
        }
        return mainDiscomposedList;
    }

Первый метод разбивает число, данное в добавленных парах, равно заданному числу. Второй и третий методы - самые уродливые, они рекурсивные и имеют буллы, поэтому они не имеют хорошей производительности. Между ними генерируется список с числами, как и говорит проблема, но есть несколько неудобств: 1) не имеют хорошей производительности 2) дает много повторяющихся последовательностей, вот результат для числа 10

[2,8,]
[2,2,6,]
[2,2,2,4,]
[2,2,2,2,2,]
[2,2,3,3,]
[2,3,5,]
[2,3,2,3,]<-------------repeated
[2,4,4,]
[2,2,2,4,]<-------------repeated
[2,4,2,2,]<-------------repeated
[3,7,]
[3,2,5,]<-------------repeated
[3,2,2,3,]<-------------repeated
[3,3,4,]
[3,3,2,2,]
[4,6,]
[2,2,6,]<-------------repeated
[4,2,4,]<-------------repeated
[4,2,2,2,]<-------------repeated
[4,3,3,]<-------------repeated
[5,5,]
[2,3,5,]<-------------repeated
[5,2,3,]<-------------repeated

Наконец, я хочу улучшить производительность и иметь как можно меньше повторяющихся элементов, являющихся повторяющимися элементами [1,1,3], [1,3,1], [3,1,1] [Вот полная ссылка на проект]1