C# 查找所有可能的组合，并允许重复显示所选项目

我有一个对象列表，这些对象的数量是动态的。我需要找到这些对象的所有可能组合

我目前正处于这样一个阶段：获取对象列表，并使用以下代码返回所有可能的组合，而无需重复：

    static void Main(string[] args)
    {
        //Say, inputList contains randomObject1,randomObject2 and randomObject3 
        List<List<RandomObject>> AllCombos = ItemCombinations(inputList);

    }

    //maxComboCount denotes the maximum number of elements that can be in the combination
    public static List<List<T>> ItemCombinations<T>(List<T> inputList, int maxComboCount)
    {
        
        int nonEmptyCombinations = (int)Math.Pow(2, inputList.Count) - 1;

        List<List<T>> listOfCombinations = new List<List<T>>();
        

        for (int i = 1; i <= nonEmptyCombinations; i++)
        {
            List<T> thisCombination = new List<T>();
            for (int j = 0; j < inputList.Count; j++)
            {
                if ((i >> j) % 2 != 0)
                {
                    thisCombination.Add(inputList[j]);
                }
            }

            if (thisCombination.Count <= maxComboCount)
            {
                listOfCombinations.Add(thisCombination);
            }
        }                     
        return listOfCombinations;
    }
    

static void Main（字符串[]args）
{
//比如说，inputList包含randomObject1、randomObject2和randomObject3
列出所有组合=项目组合（inputList）；
}
//maxComboCount表示组合中可以包含的最大元素数
公共静态列表项组合（列表inputList、int maxComboCount）
{
int nonEmptyCombinations=（int）Math.Pow（2，inputList.Count）-1；
List listOfCombinations=新列表（）；
对于（int i=1；i>j）%2！=0）
{
添加（inputList[j]）；
}
}
如果（thisCombination.Count您想从重复的
n
项目池中找到最多
m
项目的组合。项目集合中的顺序并不重要，因此
{1,2,2}
和
{2,2,1}
是等效的；只应添加其中一个。（理想情况下，这是一个项目按升序排列的项目。）

假设您有一个包含三个项目的池，并且希望创建最多包含两个项目的集合。请将空集合添加到结果中：

{}

通过迭代没有项目的集合和项目池并添加项目，创建一个项目的集合：

{} + {1} = {1}
{} + {2} = {2}
{} + {3} = {3}

现在，从包含一个项目的集合中创建两个项目的集合，但仅当它们等于或大于每个集合中最后一个和最大的项目时，才添加项目：

{1} -> {1, 1}, {1, 2}, {1, 3}
{2} -> {2, 2}, {2, 3}
{3} -> {3, 3}

现在您有了一组T（1）+T（2）+T（3）=10项：

{}
{1}, {2}, {3}
{1, 1}, {1, 2}, {1, 3}, {2, 2}, {2, 3}, {3, 3}

（T（n）是第n个三角形数，¼⁄₂·n·（n+1）。）

我不知道C#，但在伪代码中，您的算法如下所示：

var m = 3                                   // max. items
var pool = {1, 2, 3}                        // item pool
var res = {{}}                              // results,
                                            // start with empty list

var k = 0                                   // starting index of subarray
                                            // with one fewer item

while (m--) {                               // loop m times
    var kk = res.length()                   // current result array length

    for (var i = k; i < kk; i++) {
        var j0 = 0

        if (res[i].length() > 0) {          // find index of largest item
            j0 = pool.index(res[i].last())  // from the set in pool
        }

        for (var j = j0; j p in pool {      // add new set
            res.add(res[i] + {pool[j]})
        }
    }

    k = kold
}

var m=3//最大项目数
变量池={1,2,3}//项池
var res={{}//results，
//从空列表开始
var k=0//子阵列的起始索引
//少一件
而（m--）{//循环m次
var kk=res.length（）//当前结果数组长度
对于（var i=k；i0）{//查找最大项的索引
j0=pool.index（res[i].last（））//来自池中的集合
}
对于池{//中的（var j=j0；j p）添加新集合
res.add（res[i]+{pool[j]}）
}
}
k=科尔德
}

这也可以递归实现，您可以跟踪每个级别中的最后一个项目索引，这样就不必搜索它。
您所说的“不重复的可能组合”是什么意思？你是指置换还是其他什么？你能用简单的英语写出你想要的吗？我不想检查你的代码来理解你想要实现的目标。“我所需要的场景可能会陷入无限循环”这意味着你做错了什么，因为无论元素重复与否，组合的数量总是有限的（尽管它可以很快变大）@oerkelens如果我有三个对象，并且我允许重复，而不提供任何关于所需列表中可以有多少个对象的约束，那么没有什么可以阻止代码与无限重复进行组合。这就是为什么我认为它可能会出错的原因。这就是为什么你需要更清楚地了解你想要什么。正常的“不重复”的解释是123、132、213、231、312、321，而重复是111、112、113、121、122、123、131……——这意味着每个序列中项目的重复。那么你说的是什么重复，项目是否允许重复？请用这些信息编辑你的问题，并举例说明。
var m = 3                                   // max. items
var pool = {1, 2, 3}                        // item pool
var res = {{}}                              // results,
                                            // start with empty list

var k = 0                                   // starting index of subarray
                                            // with one fewer item

while (m--) {                               // loop m times
    var kk = res.length()                   // current result array length

    for (var i = k; i < kk; i++) {
        var j0 = 0

        if (res[i].length() > 0) {          // find index of largest item
            j0 = pool.index(res[i].last())  // from the set in pool
        }

        for (var j = j0; j p in pool {      // add new set
            res.add(res[i] + {pool[j]})
        }
    }

    k = kold
}