11

所以我只想找到给定数字的所有除数（数字本身除外）。目前，我有这个：

public static List<int> proper_divisors(int x)
{
    List<int> toreturn = new List<int>();
    toreturn.Add(1);
    int i = 0;
    int j=1;
    int z = 0;
    while (primes.ElementAt(i) < Math.Sqrt(x))
    {
        if (x % primes.ElementAt(i) == 0)
        {
            toreturn.Add(primes.ElementAt(i));
            toreturn.Add(x / primes.ElementAt(i));
            j = 2;
            z = (int)Math.Pow(primes.ElementAt(i), 2);
            while (z < x)
            {
                if (x % z == 0)
                {
                    toreturn.Add(z);
                    toreturn.Add(x / z);
                    j++;
                    z = (int)Math.Pow(primes.ElementAt(i), j);
                }
                else
                {
                    z = x;
                }
            }
        }
        i++;
    }
    toreturn = toreturn.Distinct().ToList<int>();
    return toreturn;
}

其中 primes 是一个素数列表（假设它是正确的，并且足够大）。该算法的工作原理是它找到所有主要因素，但不是所有因素（即给定 34534，它返回 {1,2,17267,31,1114} 但错过 {62, 557} 因为 62 是一个组合，因此也错过了 557。

我也尝试过获取一个数字的主要因素，但我不知道如何将其转换为所有正确组合的列表。

该算法的代码如下：

public static List<int> prime_factors(int x)
{
    List<int> toreturn = new List<int>();
    int i = 0;
    while (primes.ElementAt(i) <= x)
    {
        if (x % primes.ElementAt(i) == 0)
        {
            toreturn.Add(primes.ElementAt(i));
            x = x / primes.ElementAt(i);
        }
        else
        {
            i++;
        }
    }
    return toreturn;
}

关于如何修复第一个或如何从第二个创建组合列表的任何想法（我更喜欢这样，因为它会更快）？

4

2 回答 2

8

由于您已经有一个主要因素列表，您要做的是计算该列表的幂集。

现在，一个问题是您可能在列表中有重复项（例如，20 = 2 * 2 * 5 的素因子），但集合不允许重复。因此，我们可以通过将列表中的每个元素投影到 {x, y} 形式的结构中来使列表中的每个元素唯一，其中 x 是素数，y 是列表中素数的索引。

var all_primes = primes.Select((x, y) => new { x, y }).ToList();

现在，all_primes是 {x, y} 形式的列表，其中 x 是素数，y 是列表中的索引。

然后我们计算幂集（定义GetPowerSet如下）：

var power_set_primes = GetPowerSet(all_primes);

因此，power_set_primes是一个IEnumerable<IEnumerable<T>>其中T的匿名类型{x, y}，其中 x 和 y 的类型为int。

接下来，我们计算幂集中每个元素的乘积

foreach (var p in power_set_primes)
{
    var factor = p.Select(x => x.x).Aggregate(1, (x, y) => x * y);
    factors.Add(factor);
}

把它们放在一起：

var all_primes = primes.Select((x, y) => new { x, y }).ToList(); //assuming that primes contains duplicates.
var power_set_primes = GetPowerSet(all_primes);
var factors = new HashSet<int>();

foreach (var p in power_set_primes)
{
    var factor = p.Select(x => x.x).Aggregate(1, (x, y) => x * y);
    factors.Add(factor);
}

来自http://rosettacode.org/wiki/Power_Set的 powerset 实现。

public IEnumerable<IEnumerable<T>> GetPowerSet<T>(List<T> list)
{
    return from m in Enumerable.Range(0, 1 << list.Count)
           select
               from i in Enumerable.Range(0, list.Count)
               where (m & (1 << i)) != 0
               select list[i];
}
于 2011-04-26T16:28:38.710 回答
5

之前有一个类似的问题，使用 IEnumerable 有一个有趣的解决方案。如果您想要所有除数而不是因数，并假设您至少使用 C# 3.0，您可以使用如下内容：

static IEnumerable<int> GetDivisors(int n)
{
    return from a in Enumerable.Range(2, n / 2)
           where n % a == 0
           select a;                      
}

然后像这样使用它：

foreach(var divisor in GetDivisors(10))
    Console.WriteLine(divisor);

或者，如果你想要一个列表，只需：

List<int> divisors = GetDivisors(10).ToList();
于 2011-04-26T16:35:55.263 回答