C# 选中以添加-上面的将添加2两次：）Math.Sqrt返回一个double。此外，还需要对这一点进行汇总。试着以20为例，你可以重新构造循环，而不是平方根（int factor=1；factor*factor True-我可以想象，如果超过某个点，性能会因此

---

---

选中以添加-上面的将添加2两次：）Math.Sqrt返回一个double。此外，还需要对这一点进行汇总。试着以20为例，你可以重新构造循环，而不是平方根（int factor=1；factor*factor True-我可以想象，如果超过某个点，性能会因此而降低，因为您在每个循环上计算它？它可能没有循环的其他部分那么重要。我想，必须执行基准测试。酷主意标记。当您你正在让步。你知道，我希望，他的问题还没有一个通用的高性能解决方案。现代密码学依赖于没有这样的解决方案。是的，但我不确定是否有比简单地逐个测试数字更好的方法，因为我已经有一段时间没上数学课了简单的winform应用程序可能会有所帮助，因为它们是两个不同的答案，具有不同的优点。需要在for循环后添加以下内容以返回x本身。数字本身总是一个因素。

产生返回x；

我认为以前可能出错的内容现在都是正确的。它停止在平方根处的原因是因为我t已经经历了平方根以下的可能因素（需要乘以“max”以上的任何数字），以及平方根以上的任何数字（因为它输出自身和乘以的数字以获得结果）。在每次循环迭代中输出对的两侧时，尚未输出的最大可能值是平方根。例如，如果您得到的因子为81，则10到40之间的循环迭代是浪费的。当您输出3时，您已经输出27，如果您没有输出两侧，您将永远不会得到81作为因子if您在81/2（40）停车。干杯！现在确实有道理了。我会缓存

x/I

而不是计算两次，因为这只能处理整数限制以内的因子。@spencer很好奇为什么在foreach循环中使用收益率返回，因为您已经有了IEnumerable，为什么不直接返回Linq查询的结果而不是将其分配给searched？

%

实际上是“余数”，而不是“余数”。

IEnumerable

块有一个上限，这使得分解“小”（计算）数很实用。@SamuelJackson:C#5语言规范第5.8.3节不同意。您的MSDN引用是JScript，而不是C。@SamuelJackson:（鉴于MSDN页面讨论的是“模，或余数，运算符”，它看起来有点破绽，好像它认为这两个运算符是等价的……）参见-在乘法运算符一节中，它被命名为“模”，在赋值运算符和Lambda运算符下，它指出“模数分配。将x的值除以y的值，将余数存储在x中，然后返回新值。”虽然从技术上讲，模数计算是除数所有可能的除法之后剩下的内容，但此操作（在c#文档中）的正确数学术语是

模数

，有些人将其称为：。）虽然可以使用“余数”一词，但运算符是“模数”，计算结果是所有除法作为整数完成后的余数。技术性很小，但并不少见（正如您从MicrosoftSFT的一些文档中看到的）即使是那些善于混淆术语的人，也会混淆计算结果和运算符本身。我建议提供更多描述性变量名，以进一步增强可读性。

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

private IEnumerable<int> GetFactors3(int x)
{            
    for (int factor = 1; factor * factor <= x; factor++)
    {
        if (x % factor == 0)
        {
            yield return factor;
            if (factor * factor != x)
                yield return x / factor;
        }
    }
}

private IEnumerable<int> GetFactors1(int x)
{
    int max = (int)Math.Ceiling(Math.Sqrt(x));
    for (int factor = 1; factor < max; factor++)
    {
        if(x % factor == 0)
        {
            yield return factor;
            if(factor != max)
                yield return x / factor;
        }
    }
}

public List<int> Factor(int number) 
{
    var factors = new List<int>();
    int max = (int)Math.Sqrt(number);  // Round down

    for (int factor = 1; factor <= max; ++factor) // Test from 1 to the square root, or the int below it, inclusive.
    {  
        if (number % factor == 0) 
        {
            factors.Add(factor);
            if (factor != number/factor) // Don't add the square root twice!  Thanks Jon
                factors.Add(number/factor);
        }
    }
    return factors;
}

IEnumerable<int> GetFactors(int n)
{
  Debug.Assert(n >= 1);
  return from i in Enumerable.Range(1, n)
         where n % i == 0
         select i;
}

    public static bool Divides(this int potentialFactor, int i)
    {
        return i % potentialFactor == 0;
    }

    public static IEnumerable<int> Factors(this int i)
    {
        return from potentialFactor in Enumerable.Range(1, i)
               where potentialFactor.Divides(i)
               select potentialFactor;
    }

        foreach (int i in 4.Factors())
        {
            Console.WriteLine(i);
        }

    public static bool Divides(this int potentialFactor, int i)
    {
        return i % potentialFactor == 0;
    }

    public static IEnumerable<int> Factors(this int i)
    {
        foreach (int result in from potentialFactor in Enumerable.Range(1, (int)Math.Sqrt(i))
                               where potentialFactor.Divides(i)
                               select potentialFactor)
        {
            yield return result;
            if (i / result != result)
            {
                yield return i / result;
            }
        }
    }

        static IEnumerable<int> GetFactors(int n)
        {
            Debug.Assert(n >= 1);
            var pairList = from i in Enumerable.Range(1, (int)(Math.Round(Math.Sqrt(n) + 1)))
                    where n % i == 0
                    select new { A = i, B = n / i };

            foreach(var pair in pairList)
            {
                yield return pair.A;
                yield return pair.B;
            }


        }

public static IEnumerable<uint> GetFactors(uint x)
{
    for (uint i = 1; i * i <= x; i++)
    {
        if (x % i == 0)
        {
            yield return i;
            if (i != x / i)
                yield return x / i;
        }
    }
}

    public static IEnumerable<int> GetDivisors(int number)
    {
        var searched = Enumerable.Range(1, number)
             .Where((x) =>  number % x == 0)
             .Select(x => number / x);

        foreach (var s in searched)          
            yield return s;
    }

List<int> GetFactors(int n)
{
    var f = new List<int>() { 1 };  // adding trivial factor, optional
    int m = n;
    int i = 2;
    while (m > 1)
    {
        if (m % i == 0)
        {
            f.Add(i);
            m /= i;
        }
        else i++;
    }
    // f.Add(n);   // adding trivial factor, optional
    return f;
}

function getFactors(num1){
    var factors = [];
    var divider = 2;
    while(num1 != 1){
        if(num1 % divider == 0){
            num1 = num1 / divider;
            factors.push(divider);
        }
        else{
            divider++;
        }
    }
    console.log(factors);
    return factors;
}

getFactors(20);