高效程序打印n个数的因数

给定一个整数数组。我们需要编写一个程序来打印给定数组的每个元素的因子数量。
例子：

Input: 10 12 14 
Output: 4 6 4 
Explanation: There are 4 factors of 10 (1, 2, 
5, 10) and 6 of 12 and 4 of 14.

Input: 100 1000 10000
Output: 9 16 25 
Explanation: There are 9 factors of 100  and
16 of 1000 and 25 of 10000.

简单方法：一个简单的方法是运行两个嵌套循环。一种用于遍历数组，另一种用于计算数组元素的所有因子。
时间复杂度：O(n * n)
辅助空间：O(1)
高效方法：我们可以通过优化计算数量因子所需的操作数来优化上述方法。我们可以使用这种方法在sqrt(n)运算中计算n个因子。
时间复杂度：O(n * sqrt(n))
辅助空间：O(1)
最佳方法：如果您通过数论，您将找到一种找到因子数量的有效方法。如果我们取一个数字，例如在这种情况下为30，那么30的素数将是2、3、5，每个素数的计数为1倍，因此30的素数总数为(1 + 1)* (1 + 1)*(1 + 1)= 8。
因此，给定数目的因子总数的一般公式为：

Factors = (1+a1) * (1+a2) * (1+a3) * … (1+an)

其中a1，a2，a3…。是n的不同素数的计数。
让我们再举一个例子，使事情变得更清楚。这次让数字为100，
因此100将具有2、2、5、5。因此100个不同素数的计数为2、2。因此，因子数将为(2 + 1)*(2 + 1)= 9。
现在，找到素因数分解的最佳方法是最初存储素因数筛。创建筛子的方式是将其自身分裂的最小素数因子存储起来。我们可以修改Eratostheneses的筛子来做到这一点。然后简单地为每个数字找到素因数，并将其乘以求出总因数。
下面是上述方法的实现。

C++

// C++ program to count number of factors
// of an array of integers
#include 
using namespace std;
 
const int MAX = 1000001;
 
// array to store prime factors
int factor[MAX] = { 0 };
 
// function to generate all prime factors
// of numbers from 1 to 10^6
void generatePrimeFactors()
{
    factor[1] = 1;
 
    // Initializes all the positions with their value.
    for (int i = 2; i < MAX; i++)
        factor[i] = i;
 
    // Initializes all multiples of 2 with 2
    for (int i = 4; i < MAX; i += 2)
        factor[i] = 2;
 
    // A modified version of Sieve of Eratosthenes to
    // store the smallest prime factor that divides
    // every number.
    for (int i = 3; i * i < MAX; i++) {
        // check if it has no prime factor.
        if (factor[i] == i) {
            // Initializes of j starting from i*i
            for (int j = i * i; j < MAX; j += i) {
                // if it has no prime factor before, then
                // stores the smallest prime divisor
                if (factor[j] == j)
                    factor[j] = i;
            }
        }
    }
}
 
// function to calculate number of factors
int calculateNoOFactors(int n)
{
    if (n == 1)
        return 1;
 
    int ans = 1;
 
    // stores the smallest prime number
    // that divides n
    int dup = factor[n];
 
    // stores the count of number of times
    // a prime number divides n.
    int c = 1;
 
    // reduces to the next number after prime
    // factorization of n
    int j = n / factor[n];
 
    // false when prime factorization is done
    while (j != 1) {
        // if the same prime number is dividing n,
        // then we increase the count
        if (factor[j] == dup)
            c += 1;
 
        /* if its a new prime factor that is factorizing n,
           then we again set c=1 and change dup to the new
           prime factor, and apply the formula explained
           above. */
        else {
            dup = factor[j];
            ans = ans * (c + 1);
            c = 1;
        }
 
        // prime factorizes a number
        j = j / factor[j];
    }
 
    // for the last prime factor
    ans = ans * (c + 1);
 
    return ans;
}
 
// Driver program to test above function
int main()
{
    // generate prime factors of number
    // upto 10^6
    generatePrimeFactors();
 
    int a[] = { 10, 30, 100, 450, 987 };
 
    int q = sizeof(a) / sizeof(a[0]);
 
    for (int i = 0; i < q; i++)
        cout << calculateNoOFactors(a[i]) << " ";
 
    return 0;
}

Java

// JAVA Code For Efficient program to print
// the number of factors of n numbers
import java.util.*;
 
class GFG {
 
    static int MAX = 1000001;
    static int factor[];
 
    // function to generate all prime
    // factors of numbers from 1 to 10^6
    static void generatePrimeFactors()
    {
        factor[1] = 1;
 
        // Initializes all the positions with
        // their value.
        for (int i = 2; i < MAX; i++)
            factor[i] = i;
 
        // Initializes all multiples of 2 with 2
        for (int i = 4; i < MAX; i += 2)
            factor[i] = 2;
 
        // A modified version of Sieve of
        // Eratosthenes to store the
        // smallest prime factor that
        // divides every number.
        for (int i = 3; i * i < MAX; i++) {
            // check if it has no prime factor.
            if (factor[i] == i) {
                // Initializes of j starting from i*i
                for (int j = i * i; j < MAX; j += i) {
                    // if it has no prime factor
                    // before, then stores the
                    // smallest prime divisor
                    if (factor[j] == j)
                        factor[j] = i;
                }
            }
        }
    }
 
    // function to calculate number of factors
    static int calculateNoOFactors(int n)
    {
        if (n == 1)
            return 1;
 
        int ans = 1;
 
        // stores the smallest prime number
        // that divides n
        int dup = factor[n];
 
        // stores the count of number of times
        // a prime number divides n.
        int c = 1;
 
        // reduces to the next number after prime
        // factorization of n
        int j = n / factor[n];
 
        // false when prime factorization is done
        while (j != 1) {
            // if the same prime number is dividing n,
            // then we increase the count
            if (factor[j] == dup)
                c += 1;
 
            /* if its a new prime factor that is
               factorizing n, then we again set c=1
               and change dup to the new prime factor,
               and apply the formula explained
               above. */
            else {
                dup = factor[j];
                ans = ans * (c + 1);
                c = 1;
            }
 
            // prime factorizes a number
            j = j / factor[j];
        }
 
        // for the last prime factor
        ans = ans * (c + 1);
 
        return ans;
    }
 
    /* Driver program to test above function */
    public static void main(String[] args)
    {
        // array to store prime factors
        factor = new int[MAX];
        factor[0] = 0;
 
        // generate prime factors of number
        // upto 10^6
        generatePrimeFactors();
 
        int a[] = { 10, 30, 100, 450, 987 };
 
        int q = a.length;
 
        for (int i = 0; i < q; i++)
            System.out.print(calculateNoOFactors(a[i]) + " ");
    }
}
 
// This code is contributed by Arnav Kr. Mandal.

Python3

# Python3 program to count
# number of factors
# of an array of integers
MAX = 1000001;
 
# array to store
# prime factors
factor = [0]*(MAX + 1);
 
# function to generate all
# prime factors of numbers
# from 1 to 10^6
def generatePrimeFactors():
    factor[1] = 1;
 
    # Initializes all the
    # positions with their value.
    for i in range(2,MAX):
        factor[i] = i;
 
    # Initializes all
    # multiples of 2 with 2
    for i in range(4,MAX,2):
        factor[i] = 2;
 
    # A modified version of
    # Sieve of Eratosthenes
    # to store the smallest
    # prime factor that divides
    # every number.
    i = 3;
    while(i * i < MAX):
        # check if it has
        # no prime factor.
        if (factor[i] == i):
            # Initializes of j
            # starting from i*i
            j = i * i;
            while(j < MAX):
                # if it has no prime factor
                # before, then stores the
                # smallest prime divisor
                if (factor[j] == j):
                    factor[j] = i;
                j += i;
        i+=1;
 
# function to calculate
# number of factors
def calculateNoOFactors(n):
    if (n == 1):
        return 1;
    ans = 1;
 
    # stores the smallest
    # prime number that
    # divides n
    dup = factor[n];
 
    # stores the count of
    # number of times a
    # prime number divides n.
    c = 1;
 
    # reduces to the next
    # number after prime
    # factorization of n
    j = int(n / factor[n]);
 
    # false when prime
    # factorization is done
    while (j > 1):
        # if the same prime
        # number is dividing
        # n, then we increase
        # the count
        if (factor[j] == dup):
            c += 1;
 
        # if its a new prime factor
        # that is factorizing n,
        # then we again set c=1 and
        # change dup to the new prime
        # factor, and apply the formula
        # explained above.
        else:
            dup = factor[j];
            ans = ans * (c + 1);
            c = 1;
 
        # prime factorizes
        # a number
        j = int(j / factor[j]);
 
    # for the last
    # prime factor
    ans = ans * (c + 1);
 
    return ans;
# Driver Code
 
if __name__ == "__main__":
     
     
# generate prime factors
# of number upto 10^6
    generatePrimeFactors()
    a = [10, 30, 100, 450, 987]
    q = len(a)
    for i in range (0,q):
        print(calculateNoOFactors(a[i]),end=" ")
 
# This code is contributed
# by mits.

C#

// C# program to count number of factors
// of an array of integers
using System;
 
class GFG {
 
    static int MAX = 1000001;
     
    // array to store prime factors
    static int[] factor;
 
    // function to generate all prime
    // factors of numbers from 1 to 10^6
    static void generatePrimeFactors()
    {
         
        factor[1] = 1;
 
        // Initializes all the positions
        // with their value.
        for (int i = 2; i < MAX; i++)
            factor[i] = i;
 
        // Initializes all multiples of
        // 2 with 2
        for (int i = 4; i < MAX; i += 2)
            factor[i] = 2;
 
        // A modified version of Sieve of
        // Eratosthenes to store the
        // smallest prime factor that
        // divides every number.
        for (int i = 3; i * i < MAX; i++)
        {
             
            // check if it has no prime
            // factor.
            if (factor[i] == i)
            {
                 
                // Initializes of j
                // starting from i*i
                for (int j = i * i;
                          j < MAX; j += i)
                {
                     
                    // if it has no prime
                    // factor before, then
                    // stores the smallest
                    // prime divisor
                    if (factor[j] == j)
                        factor[j] = i;
                }
            }
        }
    }
 
    // function to calculate number of
    // factors
    static int calculateNoOFactors(int n)
    {
        if (n == 1)
            return 1;
 
        int ans = 1;
 
        // stores the smallest prime
        // number that divides n
        int dup = factor[n];
 
        // stores the count of number
        // of times a prime number
        // divides n.
        int c = 1;
 
        // reduces to the next number
        // after prime factorization
        // of n
        int j = n / factor[n];
 
        // false when prime factorization
        // is done
        while (j != 1) {
             
            // if the same prime number
            // is dividing n, then we
            // increase the count
            if (factor[j] == dup)
                c += 1;
 
            /* if its a new prime factor
            that is factorizing n, then
            we again set c=1 and change
            dup to the new prime factor,
            and apply the formula explained
            above. */
            else {
                dup = factor[j];
                ans = ans * (c + 1);
                c = 1;
            }
 
            // prime factorizes a number
            j = j / factor[j];
        }
 
        // for the last prime factor
        ans = ans * (c + 1);
 
        return ans;
    }
 
    /* Driver program to test above
    function */
    public static void Main()
    {
         
        // array to store prime factors
        factor = new int[MAX];
        factor[0] = 0;
 
        // generate prime factors of number
        // upto 10^6
        generatePrimeFactors();
 
        int[] a = { 10, 30, 100, 450, 987 };
 
        int q = a.Length;
 
        for (int i = 0; i < q; i++)
            Console.Write(
                   calculateNoOFactors(a[i])
                                     + " ");
    }
}
 
// This code is contributed by vt_m.

Javascript

// javascript Code For Efficient program to print
// the number of factors of n numbers
 
    var MAX = 1000001;
    var factor = [];
 
    // function to generate all prime
    // factors of numbers from 1 to 10^6
    function generatePrimeFactors() {
        factor[1] = 1;
 
        // Initializes all the positions with
        // their value.
        for (i = 2; i < MAX; i++)
            factor[i] = i;
 
        // Initializes all multiples of 2 with 2
        for (i = 4; i < MAX; i += 2)
            factor[i] = 2;
 
        // A modified version of Sieve of
        // Eratosthenes to store the
        // smallest prime factor that
        // divides every number.
        for (i = 3; i * i < MAX; i++)
        {
         
            // check if it has no prime factor.
            if (factor[i] == i)
            {
             
                // Initializes of j starting from i*i
                for (j = i * i; j < MAX; j += i)
                {
                 
                    // if it has no prime factor
                    // before, then stores the
                    // smallest prime divisor
                    if (factor[j] == j)
                        factor[j] = i;
                }
            }
        }
    }
 
    // function to calculate number of factors
    function calculateNoOFactors(n)
    {
        if (n == 1)
            return 1;
 
        var ans = 1;
 
        // stores the smallest prime number
        // that divides n
        var dup = factor[n];
 
        // stores the count of number of times
        // a prime number divides n.
        var c = 1;
 
        // reduces to the next number after prime
        // factorization of n
        var j = n / factor[n];
 
        // false when prime factorization is done
        while (j != 1)
        {
         
            // if the same prime number is dividing n,
            // then we increase the count
            if (factor[j] == dup)
                c += 1;
 
            /*
             * if its a new prime factor that is factorizing n, then we again set c=1 and
             * change dup to the new prime factor, and apply the formula explained above.
             */
            else
            {
                dup = factor[j];
                ans = ans * (c + 1);
                c = 1;
            }
 
            // prime factorizes a number
            j = j / factor[j];
        }
 
        // for the last prime factor
        ans = ans * (c + 1);
        return ans;
    }
 
    /* Driver program to test above function */
     
        // array to store prime factors
        factor = Array(MAX).fill(0);
        factor[0] = 0;
 
        // generate prime factors of number
        // upto 10^6
        generatePrimeFactors();
 
        var a = [ 10, 30, 100, 450, 987 ];
        var q = a.length;
        for (i = 0; i < q; i++)
            document.write(calculateNoOFactors(a[i]) + " ");
 
// This code is contributed by aashish1995

输出：

4 8 9 18 8