C# 找到具有特定数字集的数字的所有加法组合的算法？

我有一个问题是关于数字的加法组合

例如，我有一个函数，它使用2个整数参数来查找给定参数的所有加法组合

举例说明：

public List<List<int>> getcombinations(int numbercount, int target){
....
return List;
}

函数的输出应该是这样的：

{{1,1,7},{1,2,6},{1,3,5},{1,4,4},{2,2,5},{2,3,4},{3,3,3}}

当加上3个整数时，我们的目标数有7种可能

还有一个例子：

numbercount=2
target=7
//Output should be like this:
{{1,6},{2,5},{3,4}} // 3 possibilities when 2 integers is used in addition. 

我试图找到解决这个问题的办法。但我找不到解决的办法。

---

您建议搜索或了解什么来解决它？

这应该是一个起点，根据需要进行细化，阅读相关链接以获得有关生成组合的精彩解释

 class Program
{
    static void Main(string[] args)
    {
        foreach (var set in GetCombinations(3, 9))
        {
            Console.WriteLine("{{{0}}}", string.Join(",", set));
        }
        Console.ReadKey();
    }


    public static IEnumerable<IEnumerable<int>> GetCombinations(int length, int targetSum)
    {
        var combinations = Enumerable.Range(1, length)
            .Select(x => Enumerable.Range(1, targetSum - length+1)).CartesianProduct();
        combinations=combinations
            .Where(x => x.Sum(y => y) == targetSum);

        return combinations.Distinct(new Comparer()).ToList();
    }

}

public class Comparer : IEqualityComparer<IEnumerable<int>>
{

    public bool Equals(IEnumerable<int> x, IEnumerable<int> y)
    {
        var isEqual= x.OrderBy(a => a).SequenceEqual(y.OrderBy(b => b));
        return isEqual;
    }

    public int GetHashCode(IEnumerable<int> obj)
    {
        return obj.Sum(); //lazy me, just indicate collection is same if their sum is same.
    }
}

public static class Extensions
{
   public static IEnumerable<IEnumerable<T>> CartesianProduct<T>(this IEnumerable<IEnumerable<T>> sequences)
    {
        IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() };
        return sequences.Aggregate(
            emptyProduct,
            (accumulator, sequence) =>
                from accseq in accumulator
                from item in sequence
                select accseq.Concat(new[] { item }));
    }
}

类程序
{
静态void Main（字符串[]参数）
{
foreach（getcompositions（3，9）中的var集）
{
Console.WriteLine（“{{0}}”，string.Join（“，”，set））；
}
Console.ReadKey（）；
}
公共静态IEnumerable GetCompositions（int-length，int-targetSum）
{
变量组合=可枚举范围（1，长度）
.Select（x=>Enumerable.Range（1，targetSum-length+1））.CartesianProduct（）；
组合=组合
其中（x=>x.Sum（y=>y）==targetSum）；
返回组合.Distinct（新比较器（））.ToList（）；
}
}
公共类比较器：IEqualityComparer
{
公共布尔等于（IEnumerable x，IEnumerable y）
{
var isEqual=x.OrderBy（a=>a）.SequenceEqual（y.OrderBy（b=>b））；
回报均等；
}
public int GetHashCode（IEnumerable obj）
{
return obj.Sum（）；//lazy me，如果集合的和相同，则指示集合相同。
}
}
公共静态类扩展
{
公共静态IEnumerable CartesianProduct（此IEnumerable序列）
{
IEnumerable emptyProduct=new[]{Enumerable.Empty（）}；
返回序列.聚合(
空产品，
（累加器，顺序）=>
来自蓄能器中的accseq
按顺序从项目开始
选择accseq.Concat（新[]{item}））；
}
}

---

生成组合的扩展方法是from

此代码速度明显更快：

using System;
using System.Collections.Generic;


namespace konsol
{
class Program
{

    private static List<List<int>> combinations = new List<List<int>>();

    private static void Main(string[] args)
    {

        int length = 4
        Generate(length , 10, 0, 1, 0, new int[length]);


        foreach (var varibles in combinations)
        {
            Console.WriteLine(String.Join(",", variables));
        }

        Console.ReadKey();
    }



    private static void Generate(int length, int target, int k, int last, int sum, int[] a)
    {

        if (k == length- 1)
        {

            a[k] = target - sum;
            combinations.Add(new List<int>(a));

        }
        else
        {

            for (int i = last; i < target - sum - i + 1; i++)
            {

                a[k] = i;
                Generate(length, target, k + 1, i, sum + i, a);

            }

        }

    }

}

}

使用系统；
使用System.Collections.Generic；
名称空间konsol
{
班级计划
{
私有静态列表组合=新列表（）；
私有静态void Main（字符串[]args）
{
整数长度=4
生成（长度，10,0,1,0，新整数[length]）；
foreach（组合中的var变量）
{
Console.WriteLine（String.Join（“，”，变量））；
}
Console.ReadKey（）；
}
私有静态void Generate（int length，int target，int k，int last，int sum，int[]a）
{
如果（k==长度-1）
{
a[k]=目标和；
添加（新列表（a））；
}
其他的
{
for（int i=last；i

关于您必须遵守的规则，您有很多需要详细说明的地方。我假设“数字”是指大于0的整数。我假设结果集是无序的，即{1,2}=={2,1}。这意味着您的第二个参数可能永远不会小于第一个参数。我理解你们的要求了吗？如果我把numbercount参数赋值为3，算法会在加法过程中使用3个整数来找到目标整数。在第一个示例中：1+1+7,1+2+6,1+3+5,1+4+4,2+2+5,2+3+4,3+3+3（加法包括3个整数）

using System;
using System.Collections.Generic;


namespace konsol
{
class Program
{

    private static List<List<int>> combinations = new List<List<int>>();

    private static void Main(string[] args)
    {

        int length = 4
        Generate(length , 10, 0, 1, 0, new int[length]);


        foreach (var varibles in combinations)
        {
            Console.WriteLine(String.Join(",", variables));
        }

        Console.ReadKey();
    }



    private static void Generate(int length, int target, int k, int last, int sum, int[] a)
    {

        if (k == length- 1)
        {

            a[k] = target - sum;
            combinations.Add(new List<int>(a));

        }
        else
        {

            for (int i = last; i < target - sum - i + 1; i++)
            {

                a[k] = i;
                Generate(length, target, k + 1, i, sum + i, a);

            }

        }

    }

}

}