c#当发现所有可能的数字组合以达到给定的总和时，如何设置最大数

我是c#的新手，然后我的主管让我找到给定数字集的所有可能组合，我必须为这些组合设置最大值。我已经得到的组合，但设置最大数量无法完成。最大数量用于组合。从我的图片来看，它有5、4和3行，这是所有可能的组合。但我只想设置只显示3行的输出。我已经试了很多方法，但还是没有得到。对不起，我的英语不好

这是代码

class Program
{
static void Main(string[] args)
{

    string input;
    decimal goal;
    decimal element;
    int max = 2;

    do
    {
        Console.WriteLine("Please enter the target:");
        input = Console.ReadLine();
    }
    while (!decimal.TryParse(input, out goal));

    Console.WriteLine("Please enter the numbers (separat`enter code here`ed by spaces)");
    input = Console.ReadLine();
    string[] elementsText = input.Split(' ');
    List<decimal> elementsList = new List<decimal>();
    foreach (string elementText in elementsText)
    {
        if (decimal.TryParse(elementText, out element))
        {
            elementsList.Add(element);
        }
    }

    Solver solver = new Solver();
    List<List<decimal>> results = solver.Solve(goal, elementsList.ToArray());



    //foreach (List<decimal> result in results)
    //{
    //    foreach (decimal value in result)
    //    {
    //        Console.Write("{0}\t", value);
    //    }
    //    Console.WriteLine();
    //}


    for (int i = 0; i <= results.Count; i++)
    {

        int x = results.SelectMany(list => list).Distinct().Count();

        if (x <= max)
        {

            for (int j = 0; j <= max; j++)
            {
                Console.Write("{0}\t", results[i][j]);
            }
            Console.WriteLine();
        }
    }


    Console.ReadLine();
}
}

类程序
{
静态void Main（字符串[]参数）
{
字符串输入；
十进制目标；
十进制元素；
int max=2；
做
{
Console.WriteLine（“请输入目标：”）；
input=Console.ReadLine（）；
}
而（！decimal.TryParse（输入，输出目标））；
Console.WriteLine（“请输入数字（在此处输入代码以空格分隔）”）；
input=Console.ReadLine（）；
string[]elementsText=input.Split（“”）；
列表元素列表=新列表（）；
foreach（elementsText中的字符串elementText）
{
if（decimal.TryParse（elementText，out元素））
{
元素列表。添加（元素）；
}
}
解算器=新解算器（）；
List results=solver.Solve（goal，elementsList.ToArray（））；
//foreach（在结果中列出结果）
//{
//foreach（结果中的十进制值）
//    {
//写入（“{0}\t”，值）；
//    }
//Console.WriteLine（）；
//}
对于（int i=0；i list）.Distinct（）.Count（）；
如果（x很难找到你想要做的事情，是这样的吗

List<string> numbers = new List<string>(){"1","2","3","4","5"};
List<string> possibleCombination = GetCombination(numbers, new List<string>(), "");
Console.Write(string.Join(", ",possibleCombination.Distinct().OrderBy(itm => itm)));

List number=newlist（）{“1”、“2”、“3”、“4”、“5”}；
List possibleCombination=GetCombination（数字，新列表（），“”）；
Write（string.Join（“，”，possibleCombination.Distinct（）.OrderBy（itm=>itm））；

方法

static List<string> GetCombination(List<string> list, List<string> combinations, string sumNum, bool addNumberToResult = false)
    {
        if (list.Count == 0) {
            return combinations;
        }

        string tmp;

        for (int i = 0; i <= list.Count - 1; i++) {
            tmp = string.Concat(sumNum , list[i]);
            if(addNumberToResult){
                combinations.Add(tmp);
            }
            List<string> tmp_list = new List<string>(list);
            tmp_list.RemoveAt(i);
            GetCombination(tmp_list,combinations,tmp, true);
        }

        return combinations;
    }

static List getcomposition（列表列表、列表组合、字符串sumNum、bool addNumberToResult=false）
{
如果（list.Count==0）{
收益组合；
}
串tmp；
对于（int i=0；i这是我的尝试，您可以根据需要调整它：

using System.Collections.Generic;
using System.Linq;        
private static void GetMaxPermutation(int max)
        {
            var numbers = new[] { 1, 2, 4, 6, 7 };
            var results = new List<IEnumerable<int>>();
            for (int i = 1; i <= numbers.Length; i++)
            {
                results.AddRange(GetPermutations(numbers, i));
            }
            Console.WriteLine("Result: " + string.Join(" ", results.Select(x => new { Target = x, Sum = x.Sum() }).Where(x => x.Sum <= max).OrderByDescending(x => x.Sum).FirstOrDefault().Target));
        }

    private static IEnumerable<IEnumerable<T>> GetPermutations<T>(IEnumerable<T> items, int count)
    {
        int i = 0;
        foreach (var item in items)
        {
            if (count == 1)
                yield return new T[] { item };
            else
            {
                foreach (var result in GetPermutations(items.Skip(i + 1), count - 1))
                    yield return new T[] { item }.Concat(result);
            }

            ++i;
        }
    }

使用System.Collections.Generic；
使用System.Linq；
私有静态void GetMaxPermutation（int max）
{
变量数=新[]{1,2,4,6,7}；
var results=新列表（）；
对于（inti=1；i new{Target=x，Sum=x.Sum（）}），其中（x=>x.Sum x.Sum）.FirstOrDefault（）.Target）；
}
私有静态IEnumerable GetPermutations（IEnumerable项，int计数）
{
int i=0；
foreach（项目中的var项目）
{
如果（计数=1）
返回新的T[]{item}；
其他的
{
foreach（变量结果在GetPermutations中（items.Skip（i+1），count-1））
返回新的T[]{item}.Concat（结果）；
}
++一,；
}
}

我从问题中的注释和其他答案中得到了这种排列方法，在我看来，OP已经知道如何计算其和为目标数的所有组合（这可能是问题中的
解算器所做的）.我认为他想要的是得到数量最少的组合

我有两个解决方案，因为我不确定您想要什么：

using System.Collections.Generic;
using System.Linq;        
private static void GetMaxPermutation(int max)
        {
            var numbers = new[] { 1, 2, 4, 6, 7 };
            var results = new List<IEnumerable<int>>();
            for (int i = 1; i <= numbers.Length; i++)
            {
                results.AddRange(GetPermutations(numbers, i));
            }
            Console.WriteLine("Result: " + string.Join(" ", results.Select(x => new { Target = x, Sum = x.Sum() }).Where(x => x.Sum <= max).OrderByDescending(x => x.Sum).FirstOrDefault().Target));
        }

    private static IEnumerable<IEnumerable<T>> GetPermutations<T>(IEnumerable<T> items, int count)
    {
        int i = 0;
        foreach (var item in items)
        {
            if (count == 1)
                yield return new T[] { item };
            else
            {
                foreach (var result in GetPermutations(items.Skip(i + 1), count - 1))
                    yield return new T[] { item }.Concat(result);
            }

            ++i;
        }
    }

1） 如果希望所有组合的数字数量最少，请执行以下操作：

publicstaticvoidmain（）
{
//这里我已经硬编码了所有的组合，
//但在现实生活中，你会计算它们。
//可能使用您的“解算器”或本页中的任何其他答案。
var组合=新列表{
新名单{1,2,3,4,5}，
新名单{1,2,5,7}，
新名单{1,3,4,7}，
新名单{1,3,5,6}，
新名单{2,3,4,6}，
新名单{2,6,7}，
新名单{3,5,7}，
新名单{4,5,6}
};
//筛选上面的列表以仅保留列表
//数量最少的。
var filteredCombinations=最小数量（组合）；
foreach（过滤组合中的var组合）
{
Console.WriteLine（string.Join（“\t”，组合））；
}
}
公共静态列表最小编号（列表组合）
{
//首先得到每个组合的计数，然后得到其中的最小值。
int smallestLength=combines.Select（l=>l.Count）.Min（）；
//其次，只保留计数等于上述计算值的组合。
返回组合。其中（l=>l.Count==smallestLength.ToList（）；
}

输出：

267
3    5    7
4    5    6

2） 如果您只需要其中一个数字最少的组合，请执行以下操作：

publicstaticvoidmain（）
{
//这里我已经硬编码了所有的组合，
//但在现实生活中，你会计算它们。
//可能使用您的“解算器”或本页中的任何答案。
var组合=新列表{
新名单{1,2,3,4,5}，
新名单{1,2,5,7}，
新名单{1,3,4,7}，
新名单{1,3,5,6}，
新名单{2,3,4,6}，
新名单{2,6,7}，
新名单{3,5,7}，
新名单{4,5,6}
};
//筛选上面的列表以仅保留第一个列表
//数量最少的。
var FilteredComposition=最小数量（组合）；
Console.WriteLine（string.Join（“\t”，filteredcomposition））；
}
公共静态列表最小编号（列表组合）
{
//首先得到每个组合的计数，
//然后取最小值。
int smallestLength=combines.Select（l=>l.Count）.Min（）；
//其次，只获取一个具有计数的组合
//等于上面计算的值。
返回组合。第一（l=