乘法组合（简单C#）

我有一个长度可变的ulong素数列表

例：2,5,7,3

我想创建每一个相乘的组合，不包括所有相乘的数字。 （本例中为2*5*7*3）

例：2,3,5,6,7,10,14,15,21,30,35,42,70105

我已经尝试过使用“foreach”循环的几种解决方案，但似乎无法实现。这似乎太容易了。什么可能是一种有效的方法

我遇到的主要问题是，当我向列表中添加新值时，“foreach”循环会导致错误，因为我更改了它。除了做一大堆新的列表，我想不出其他办法来解决这个问题。在我看来，应该有一个非常简单、干净的解决方案，我只是把它复杂化了

我尝试了“构建”方法，将基本因子相乘，创建更大的因子，以此类推，“构建”方法，从大的数字开始，然后分解它（如我的示例所示）。这就是我所尝试的：

List<ulong> c, f;
ulong i;
//Some code then sets c to the factors (2, 3, 5, and 7)
//i is then set to the c set multiplied together (2*3*5*7)

//if the c is a factor, divide and add it to the new list f (the final list)
foreach (ulong u in c) 
{
    if (i % u == 0)
    {
        f.Add(i/u);
        Console.WriteLine(i / u);
    }
}

// Keep on dividing the numbers down, until you get the original factors added to the list
for (int j = 0; j < f.Count -1; j++)
{
    foreach (ulong u in c)
    {
        foreach (ulong v in f)
        {
            if (v % u == 0)
            {
                if (v / u != 1 && !f.Contains(v / u))
                {
                    f.Add(v / u);
                }
            }
        }
    }
}

列表c、f；
乌隆一世；
//然后，一些代码将c设置为因子（2、3、5和7）
//然后将i设置为c集，并将其相乘（2*3*5*7）
//如果c是一个因子，则将其除以并添加到新列表f（最终列表）中
foreach（c中的ulong u）
{
如果（i%u==0）
{
f、 添加（i/u）；
控制台写入线（i/u）；
}
}
//继续向下划分数字，直到将原始因子添加到列表中
对于（int j=0；j

带输入的预期输出（2 5 7 3）：

• 二,
• 五,
• 三,
• 七,
• 2*3=6
• 2*5=10
• 2*7=14
• 5*7=35
• 5*3=15
• 7*3=21
• 2*5*7=70
• 2*5*3=30
• 2*3*7=42
• 5*7*3=105

---

以下代码应能准确地为您提供列表中任意数量的项目所需的信息

class Program
{
    static void Main(string[] args)
    {
        MultiplyFactors(new List<ulong>() { 2, 3, 5, 7 });

        Console.ReadLine();
    }

    public static void MultiplyFactors(List<ulong> numbers)
    {
        var factorCombinations = CreateSubsets(numbers.ToArray());

        foreach (var factors in factorCombinations)
        {
            // set initial result to identity value. (any number multiplied by itself is 1)
            ulong result = 1;

            // multiply all factors in combination together
            for (int i = 0; i < factors.Count(); i++)
            {
                result *= factors[i];
            }

            // Output for Display
            Console.WriteLine(String.Format("{0}={1}", String.Join("x", factors), result));

        }
    }

    private static List<T[]> CreateSubsets<T>(T[] originalArray)
    {
        // From http://stackoverflow.com/questions/3319586/getting-all-possible-permutations-from-a-list-of-numbers
        var subsets = new List<T[]>();

        for (int i = 0; i < originalArray.Length; i++)
        {
            int subsetCount = subsets.Count;
            subsets.Add(new T[] {originalArray[i]});

            for (int j = 0; j < subsetCount; j++)
            {
                T[] newSubset = new T[subsets[j].Length + 1];
                subsets[j].CopyTo(newSubset, 0);
                newSubset[newSubset.Length - 1] = originalArray[i];
                subsets.Add(newSubset);
            }
        }

        return subsets;
    }
}

---

这可能是通过递归实现的，但这个方法可能同样简单。诀窍是创建子集列表。一旦有了它，您只需将每个子集的所有元素相乘即可

这可以获得您想要的数字：

Func<IEnumerable<ulong>, IEnumerable<ulong>> f = null;
f = xs =>
{
    if (xs.Any())
    {
        return f(xs.Skip(1))
            .SelectMany(x =>
                new [] { xs.First() * x, x });
    }
    else
    {
        return new ulong[] { 1 };
    }
};

我不得不做

Skip/Take

来摆脱你想要避免的两个案例

我得到的结果是：

如果您想将其作为（几乎）一个衬里，请选择：

Func<IEnumerable<ulong>, IEnumerable<ulong>> f = null;
f = xs => xs.Any() ? f(xs.Skip(1)).SelectMany(x => new [] { xs.First() * x, x }) : new ulong[] { 1 };

Func f=null；
f=xs=>xs.Any（）？f（xs.Skip（1））.SelectMany（x=>new[]{xs.First（）*x，x}）：new-ulong[]{1}；

这不是解决家庭作业问题的好地方。请先向我们展示您迄今为止所做的尝试。记住，点击几次回车键让你的问题更具可读性并没有什么坏处。这是一种爱好编程。。。我会添加一些例子。听起来像是一个递归的解决方案将要走的路。。。在寻求帮助之前，自己尝试一下。我不明白你所说的“除了所有的数字加起来（本例中为2*5*7*3）”是什么意思。抱歉，这意味着2*5*7*3（210）被排除在列表之外，但所有其他组合都有效

var primes = new ulong[] { 2, 5, 7, 3 };

var results = f(primes)
    .OrderBy(x => x)
    .ToArray();

results = results
    .Skip(1)
    .Take(results.Length - 2)
    .ToArray();

Func<IEnumerable<ulong>, IEnumerable<ulong>> f = null;
f = xs => xs.Any() ? f(xs.Skip(1)).SelectMany(x => new [] { xs.First() * x, x }) : new ulong[] { 1 };