C#遍历输出从n个数中选择m个数的可以重复取数的所有组合

目录

1.可重复取数的C(n,m)组合数

2.编程实现C(5, 3)可重复取数的组合并遍历输出

---

1.可重复取数的C(n,m)组合数

        要计算从n个数中任取m个数的可以重复取数的组合数，可以使用数学中的组合公式。在这种情况下，我们可以将问题看作是从n个数中选择m个数，其中每个数可以重复选择。

        这种情况下，组合数的公式为：C(n, m) = n^m

        其中，n是可供选择的数的总数，m是要选择的数的数量，C(n, m)表示从n个数中选择m个数的组合数。

        例如，从5个不重复的数中选择3个数，可以重复选择的组合数为：C(5, 3) = 5^3 = 125。

        因此，从5个不重复的数中选择3个数，可以重复选择的组合数为125种。

2.编程实现C(5, 3)可重复取数的组合并遍历输出

        程序首先定义了两个变量n和m，分别表示不重复的数的数量和需要选择的数的数量。然后，程序通过调用GenerateCombinations方法生成所有可能的组合。GenerateCombinations方法是一个递归方法，它根据m的值生成所有可能的组合。最后，程序将所有可能的组合输出到控制台。

// 计算从n个数中选择m个数的可以重复取数的组合数

namespace _152_1
{
    class CombinationCount
    {
        static void Main(string[] args)
        {
            ArgumentNullException.ThrowIfNull(args);

            int n = 5; // 不重复的数的数量
            int m = 3; // 需要选择的数的数量

            var combinations = GenerateCombinations(n, m).ToList();

            Console.WriteLine("从n={0}个不重复的数中选择m={1}个数，可以重复取数的组合数为：{2}", n, m, combinations.Count);
            Console.WriteLine("所有可能的组合：");
            foreach (var combination in combinations)
            {
                Console.WriteLine(string.Join(", ", combination));
            }
        }

        static IEnumerable<IEnumerable<int>> GenerateCombinations(int n, int m)
        {
            if (m == 0)
            {
                yield return Enumerable.Empty<int>();
            }
            else
            {
                for (int i = 0; i < n; i++)
                {
                    foreach (var combination in GenerateCombinations(n, m - 1))
                    {
                        yield return combination.Concat([i]);
                    }
                }
            }
        }
    }
}
//运行结果“
/*
从n=5个不重复的数中选择m=3个数，可以重复取数的组合数为：125
所有可能的组合：
0, 0, 0
1, 0, 0
2, 0, 0
3, 0, 0
4, 0, 0
0, 1, 0
1, 1, 0
2, 1, 0
3, 1, 0
4, 1, 0
0, 2, 0
1, 2, 0
2, 2, 0
3, 2, 0
4, 2, 0
0, 3, 0
1, 3, 0
2, 3, 0
3, 3, 0
4, 3, 0
0, 4, 0
1, 4, 0
2, 4, 0
3, 4, 0
4, 4, 0
0, 0, 1
1, 0, 1
2, 0, 1
3, 0, 1
4, 0, 1
0, 1, 1
1, 1, 1
2, 1, 1
3, 1, 1
4, 1, 1
0, 2, 1
1, 2, 1
2, 2, 1
3, 2, 1
4, 2, 1
0, 3, 1
1, 3, 1
2, 3, 1
3, 3, 1
4, 3, 1
0, 4, 1
1, 4, 1
2, 4, 1
3, 4, 1
4, 4, 1
0, 0, 2
1, 0, 2
2, 0, 2
3, 0, 2
4, 0, 2
0, 1, 2
1, 1, 2
2, 1, 2
3, 1, 2
4, 1, 2
0, 2, 2
1, 2, 2
2, 2, 2
3, 2, 2
4, 2, 2
0, 3, 2
1, 3, 2
2, 3, 2
3, 3, 2
4, 3, 2
0, 4, 2
1, 4, 2
2, 4, 2
3, 4, 2
4, 4, 2
0, 0, 3
1, 0, 3
2, 0, 3
3, 0, 3
4, 0, 3
0, 1, 3
1, 1, 3
2, 1, 3
3, 1, 3
4, 1, 3
0, 2, 3
1, 2, 3
2, 2, 3
3, 2, 3
4, 2, 3
0, 3, 3
1, 3, 3
2, 3, 3
3, 3, 3
4, 3, 3
0, 4, 3
1, 4, 3
2, 4, 3
3, 4, 3
4, 4, 3
0, 0, 4
1, 0, 4
2, 0, 4
3, 0, 4
4, 0, 4
0, 1, 4
1, 1, 4
2, 1, 4
3, 1, 4
4, 1, 4
0, 2, 4
1, 2, 4
2, 2, 4
3, 2, 4
4, 2, 4
0, 3, 4
1, 3, 4
2, 3, 4
3, 3, 4
4, 3, 4
0, 4, 4
1, 4, 4
2, 4, 4
3, 4, 4
4, 4, 4

 */