嵌套 for 循环的动态数量，用于列出对象的唯一组合

Question

我有 n 个对象列表，我需要将它们转换为对象数组列表，每个对象数组包含原始列表中对象的唯一组合。

示例：

myList[0] = new List<object>(){a, b, c, d};
myList[1] = new List<object>(){"0", "1", "2", "3", "4"};
myList[2] = new List<object>(){0, 1, 2};
myList[3] = new List<object>(){aClass, bClass}

等等

需要成为：

newList[0] =  new object[]{a, "0", 0, aClass};
newList[1] =  new object[]{a, "0", 0, bClass};
newList[2] =  new object[]{a, "0", 1, aClass};
newList[3] =  new object[]{a, "0", 1, bClass};
newList[4] =  new object[]{a, "0", 2, aClass};
newList[5] =  new object[]{a, "0", 2, bClass};
newList[6] =  new object[]{a, "1", 0, aClass};
newList[7] =  new object[]{a, "1", 0, bClass};
newList[8] =  new object[]{a, "1", 1, aClass};
newList[9] =  new object[]{a, "1", 1, bClass};
newList[10] = new object[]{a, "1", 2, aClass};
newList[11] = new object[]{a, "1", 2, bClass};

等等

必须保留变量的顺序（myList[0] 中的列表必须在前面，等等）因为这些对象数组是通过反射传递的参数：

Indicator temp = (Indicator) newIndicator.Invoke(this, newList[i]);

如果对象列表的数量是静态的，则可能如下所示：

List<object[]> newList = new List<object[]>();
for(int i = 0; i < myList[0].Count; i++)
{
    for(int i2 = 0; i2 < myList[1].Count; i2++)
    {
        for(int i3 = 0; i3 < myList[2].Count; i3++)
        {
            for(int i4 = 0; i4 < myList[3].Count; i4++)
            {
                object[] temp = new object[]{myList[0][i], myList[1][i2], myList[2][i3], myList[3][i4]};
                newList.Add(temp);
            }
        }
    }
}

我最近的尝试是创建一个索引列表，其中包含每个列表的当前索引并适当地递增它，但我的数学似乎并没有在我扩展它时解决。

        private List<object[]> ToParametersList(List<List<object>> listOfLists)
    {
        int counter = 1;
        foreach(List<object> list in listOfLists){ counter *= list.Count; }

        List<object[]> returnList = new List<object[]>();

        List<int> indicies = new List<int>();
        int tempSplit = 0;
        List<int> splits = new List<int>();
        List<int> splitcounters = new List<int>();
        for(int i = 0; i < listOfLists.Count; i++)
        {
            if(i == 0 && listOfLists[0].Count > 2)
            {
                splits.Add(counter / listOfLists[0].Count);
                tempSplit = counter / listOfLists[0].Count;
            } else if(i > 0 && listOfLists[i].Count > 2) {
                splits.Add(tempSplit / listOfLists[i].Count);
                tempSplit /= listOfLists[i].Count;
            } else if(listOfLists[i].Count == 2)
            {
                splits.Add(1);
            }
            indicies.Add(0);
            splitcounters.Add(1);
        }
        for(int i = 0; i < counter; i++)
        {
            object[] newObject = new object[listOfLists.Count];
            for(int i2 = 0; i2 < listOfLists.Count; i2++)
            {
                if(i < splits[i2] * splitcounters[i2] && ((indicies[i2] < listOfLists[i2].Count && listOfLists[i2].Count > 2) || indicies[i2] < listOfLists[i2].Count - 1))
                {
                    newObject[i2] = listOfLists[i2][indicies[i2]];
                }
                else if(i >= splits[i2] * splitcounters[i2] && ((indicies[i2] < listOfLists[i2].Count && listOfLists[i2].Count > 2) || indicies[i2] < listOfLists[i2].Count - 1))
                {
                    indicies[i2]++;
                    splitcounters[i2]++;
                    newObject[i2] = listOfLists[i2][indicies[i2]];
                }
                else
                {
                    indicies[i2] = 0;
                    splitcounters[i2]++;
                    newObject[i2] = listOfLists[i2][indicies[i2]];
                }
            }
            returnList.Add(newObject);
        }
        return returnList;
    }

我也已经解决了这里的许多递归问题，但仍然无法理解如何将它们应用于这种特定情况（我对递归比较陌生）。

如有任何帮助，我们将不胜感激！

编辑：在 Cartesian products with n number of list the OP's post is confusing and the answer provided has no explanation of what is happening. The link to Eric Lippert's Blog 中是对笛卡尔积的一般概述，它并没有帮助我打破障碍，我需要在我尝试做的事情的背景下正确理解它。

Answer 1

您可以使用 LINQ 获取对象列表的笛卡尔积。

List<object> arr1 = new List<object> { "a", "b", "c" };
            List<object> arr2 = new List<object> { 3, 2, 4,5 };
            List<object> arr3 = new List<object> { "0", "1", "2", "3", "4" };


            var result = from x in arr1
                         from y in arr2
                         from z in arr3
                         select new { x = x, y = y,z=z };

            List<object[]> newList = new List<object[]>();

            foreach (var line in result)
            {
                newList.Add(new object[] { line.x, line.y, line.z });                     
            }

            foreach (var obj in newList)
            {
                foreach (var ele in obj)
                {
                    Console.Write(ele.ToString() + " ");
                }
                Console.WriteLine();
            }
            Console.ReadKey();

这将以您需要的方式为您提供一个对象的列表。

这里是运行例子 http://csharppad.com/gist/45ebe7c9576dab9c00b8

Answer 2

这里有一个解决方案，它接受一些在编译时未知的列表。
方法 CombineArrayOfLists 满足您的需求：

    static List<List<object>> CombineArrayOfLists(List<object>[] myList)
    {
        List<List<object>> result = myList[0].Select(element => new List<object>() { element }).ToList();

        for (int i = 1; i < myList.Length; i++)
        {
            result = (from c1 in result from c2 in myList[i] select new List<object>(c1) {c2}).ToList();
        }

        return result;
    }

请注意，您需要定义所需的行为，以防列表数组中的任何列表为空。要处理这种情况，您可能需要添加一个 if 语句来跳过该列表（如果这样做合适的话）。

一个完整的例子，写得比较冗长，更容易理解：

class Program
{
    static void Main(string[] args)
    {
        List<object>[] myList = new List<object>[4];

        AClass aClass = new AClass();
        BClass bClass = new BClass();

        myList[0] = new List<object>() { "a", "b", "c", "d" };
        myList[1] = new List<object>() { "0", "1", "2", "3", "4" };
        myList[2] = new List<object>() { 0, 1, 2 };
        myList[3] = new List<object>() { aClass, bClass };

        List<List<object>> result = CombineArrayOfLists(myList);

        PrintList(result);
    }

    static List<List<object>> CombineArrayOfLists(List<object>[] myList)
    {
        List<List<object>> result = myList[0].Select(element => new List<object>() { element }).ToList();

        for (int i = 1; i < myList.Length; i++)
        {
            result = CombineCollections(result, myList[i]).ToList();
        }

        return result;
    }

    private static IEnumerable<List<object>> CombineCollections(IEnumerable<List<object>> collection1, List<object> collection2)
    {
        return from c1 in collection1 from c2 in collection2 select new List<object>(c1) { c2 };
    }

    // A more verbose form of CombineCollections that may be easier to understand:
    //private static IEnumerable<List<object>> CombineCollections(IEnumerable<List<object>> collection1, List<object> collection2)
    //{
    //    foreach (List<object> c1 in collection1)
    //    {
    //        foreach (object c2 in collection2)
    //        {
    //            List<object> l1 = new List<object>(c1) { c2 };
    //            yield return l1;
    //        }
    //    }
    //}

    private static void PrintList(List<List<object>> collection)
    {
        collection.ForEach(list =>
        {
            list.ForEach(element =>
            {
                Console.Write(element);
                Console.Write(" ");
            });

            Console.WriteLine();
        });
    }
}

public class AClass
{ }

public class BClass
{ }

Answer 3

老实说，我没有读到你最后的尝试。其他使用 Linq 的方法很棒，但如果您真的想要递归，请遵循这种方式。

要创建良好的递归，您需要查看方法的哪一部分不同，哪部分不变。该方法应采用随每次调用而变化的参数。你还需要 if-else 在某处结束递归。

List<object[]> newList = new List<object[]>();
for(int i = 0; i < myList[0].Count; i++)
{
    for(int i2 = 0; i2 < myList[1].Count; i2++)
    {
        for(int i3 = 0; i3 < myList[2].Count; i3++)
        {
            for(int i4 = 0; i4 < myList[3].Count; i4++)
            {
                object[] temp = new object[]{myList[0][i], myList[1][i2], myList[2][i3], myList[3][i4]};
                newList.Add(temp);
            }
        }
    }
}

我们希望在此方法中使用递归，以便能够将其用于任何长度 list.To 为此，您必须将循环转换为递归调用。但现在你有未知数量的循环。

解决方案是使用 params 关键字。您可以向方法发送任意数量的 int。这个 int 包含变量 i1, i2 , i3 , i4 ...。就像你写的上面的方法一样。

这个数组的长度 (params int[]) 恰好是普通方法中的循环数。

private static void Combine(List<List<object>> myList,List<object[]> newList,params int[] loopInd)
{
    if (loopInd.Length <= myList.Count) // should not exceed number of loops.
    {
        int currentCount = myList[loopInd.Length - 1].Count;

        while (loopInd[loopInd.Length - 1] < currentCount) // i<myList[0] , i2<myList[1] , i3<myList[2]
        {
            Combine(myList, newList, loopInd.Concat(new[] {0}).ToArray()); // Go for inner loop
            loopInd[loopInd.Length - 1]++; // i++, i2++ , i3++ ...
        }
    }
    else // no more loops.add the object[] into newList
    {
        int j = 0;
        object[] temp = loopInd.Take(loopInd.Length - 1).Select(i => myList[j++][i]).ToArray();
        newList.Add(temp);
    }
}

上面的注释是正常方法中的表示。

那么就可以这样使用了

List<List<object>> myList = new List<List<object>>();
myList.Add(new List<object>() { a, b, c, d });
myList.Add(new List<object>() { "0", "1", "2", "3", "4" });
myList.Add(new List<object>() { 0, 1, 2 });
myList.Add(new List<object>() {aClass, bClass});

List<object[]> newList = new List<object[]>();

Combine(myList, newList, 0);

        // The newList is now what you want

编辑：

如果您追求性能，可以转换此 Linq 部分

int j = 0;
object[] temp = loopInd.Take(loopInd.Length - 1).Select(i => myList[j++][i]).ToArray();
newList.Add(temp);

进入代码

int j = 0;
object[] temp = new object[loopInd.Length - 1];

for (int i = 0; i < loopInd.Length - 1; i++,j++) 
{
    temp[i] = myList[j][loopInd[i]];
}

嵌套 for 循环的动态数量，用于列出对象的唯一组合

Dynamic number of nested for loops to list unique combinations of objects

c#

arrays

recursion

dynamic

object