Question

所以我有一个ulong素数列表，长度可变。

Ex：2,5,7,3

我想创建每个乘法组合，不包括所有数字相乘。（在这种情况下为2 * 5 * 7 * 3）。

Ex：2,3,5,6,7,10,14,15,21,30,35,42,70,105。

我尝试使用＆＃34; foreach＆＃34;循环，但我似乎无法得到它。这似乎太容易了。什么可能是一个有效的方法来解决这个问题？

我遇到的主要问题是，当我向列表添加新值时，＆＃34; foreach＆＃34;循环导致错误，因为我改变了它。除了做一大堆新列表之外，我无法想到解决方法。在我看来，应该有一个非常简单，干净的解决方案，我只是过于复杂。

我尝试了＃34;积累＆＃34;接近，将基本因素相乘，创建更大的等等，以及＆＃34;构建＆＃34;接近，从大数字开始，然后分解它（在我的例子中显示）。这就是我试过的：

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);
                }
            }
        }
    }
}

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

2
5
3
7
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

Answer 1

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

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 };
    }
};

你这样使用它：

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();

我必须做Skip/Take来摆脱你想要避免的两个案例。

我得到的结果是：

result

如果你喜欢这里（几乎）单行，那就是：

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 };

Answer 2

以下代码可为您提供列表中任意数量项目所需的确切内容

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;
    }
}

这将为您输入2,3,5,7。

提供以下结果

2=2
3=3
2x3=6
5=5
2x5=10
3x5=15
2x3x5=30
7=7
2x7=14
3x7=21
2x3x7=42
5x7=35
2x5x7=70
3x5x7=105
2x3x5x7=210

这可能是通过递归，但这种方法可能同样简单。诀窍是创建子集列表。完成后，您只需将每个子集的所有元素相乘即可。

乘法组合（简单C＃）

2 个答案: