Question

我有以下课程：

internal class Course
{
    public int CourseCode { get; set; }
    public string DeptCode { get; set; }
    public string Name { get; set; }
}

以下代码是我的二维数组：

Course[][] courses = new Course[3][];
courses[0] = new Course[] {
   new Course() { CourseCode = 100, DeptCode = "EGR", Name = "EGR A" },
   new Course() { CourseCode = 100, DeptCode = "EGR", Name = "EGR B" }
};

courses[1] = new Course[] {
   new Course() { CourseCode = 200, DeptCode = "EN", Name = "EN A" }
};

courses[2] = new Course[] {
   new Course() { CourseCode = 300, DeptCode = "PHY", Name = "PHY A" }
};

我想要做的是获得组中每个项目可以与其他组进行的不同组合;例如，使用前面的代码，结果将是：

1. EGR A - EN A - PHY A
2. EGR B - EN A - PHY A

回答：为了获得可能的组合数量，我们可以使用Rule of Product，在上面的例子中，可能的组合将是（2 * 1 * 1）= 2，这实际上是我上面写的两个组合。

LordTakkera给出了完美的答案，非常感谢你！

Answer 1

看一下你的第二个索引 - 0或1.如果只查看它，你会看到一个从0到7的二进制数。

从0到7计数，将其转换为位并获得所需的组合模式。

Answer 2

您可以使用嵌套for循环：

for (int i = 0; i < courses[0].Length; i++)
{
   for (int j = 0; j < courses[1].Length; i++)
   {
     for (int k = 0; k < courses[2].Length; i++)
     {
         //Do whatever you need with the combo, accessed like:
         //courses[0][i], courses[1][j], courses[2][k]
     }
   }
}

当然，这个解决方案变得非常麻烦你需要的嵌套越多。如果你需要更深入，我会使用某种递归函数来遍历集合并生成组合。

这将是：

class CombinationHelper
{
    public List<List<Course>> GetAllCombinations(Course[][] courses)
    {
            return GetCourseCombination(courses, 0);
    }

    public List<List<Course>> GetCourseCombination(Course[][] courses, int myIndex)
    {
        List<List<Course>> combos = new List<List<Course>>();

        for (int i = 0; i < courses[myIndex].Length; i++)
        {
            if (myIndex + 1 < courses.GetLength(0))
            {
               foreach (List<Course> combo in GetCourseCombination(courses, myIndex + 1))
               {
                  combo.Add(courses[myIndex][i]);
                  combos.Add(combo);
               }
            }
            else
            {
               List<Course> newCombination = new List<Course>() { courses[myIndex][i] };
               combos.Add(newCombination);
            }
        }
        return combos;
    }
}

我对此进行了测试（将“int”替换为“Course”以使验证更容易）并且它产生了所有8种组合（虽然不按顺序，递归往往会这样做。如果我想出订购代码，我会发布，但它不应该太困难）。

递归函数对我来说已经足够难了，所以我的解释不会很好。基本上，我们首先用“0”索引踢掉整个事物（所以我们从头开始）。然后我们迭代当前数组。如果我们不是“master”数组中的最后一个数组，我们将进入下一个子数组。否则，我们会创建一个新组合，将其添加到其中并返回。

当递归堆栈“展开”时，我们将生成的组合添加到返回列表中，将其添加到其中，然后再次返回。最终整个事情“解开”，你留下了所有组合的一个列表。

同样，我确信这是一个非常令人困惑的解释，但递归算法（至少对我而言）本质上令人困惑。我很乐意尝试详细说明你想要的任何一点。

订购独特的组合

2 个答案: