计数产生相同商和余数的除数

给定一个正整数N ，任务是找到所有数字M的计数，使得当数字N除以M 时，商等于它的余数，即(⌊N/M⌋ = N mod M)其中⌊ ⌋表示给定数字的下限值。

例子：

Input: N = 8
Output: 2
Explanation: When 8 is divided by 3 and 7, it returns the same Quotient and Remainder.
8 / 3 = 8 % 3, 8 / 7 = 8 % 7. Therefore, the required answer is 2.

Input: N = 1000000000000
Output: 84

朴素的方法：最简单的方法是基于M不能大于N的事实，因为对于任何大于N的数，商将为零。然而，它与N 的模将始终为N 。因此，遍历从1 到 N 的所有数字并计算所有满足给定条件的数字。

时间复杂度： O(N)
辅助空间： O(1)

有效的方法：最佳想法基于以下观察：

If (⌊N/M⌋ = N mod M), then M + 1 must be a divisor of N.

观察证明：

If ⌊N/M⌋ = N mod M, then let N / M be equal to K.
Therefore, N must be equal to K * M + K as K is the quotient as well as the remainder.
                             N = K * M + K
                             N = K * (M + 1)
Therefore, for M to be in our answer set, it is necessary that M + 1 is a divisor of N.
Note that M + 1 must be a divisor of N is a necessary condition but not a sufficient condition for ⌊N/M⌋ = N mod M.

请按照以下步骤解决问题：

• 找到 N 的所有除数并将它们存储在一个数组中。这可以以 O(√ N) 复杂度计算。
• 通过遍历数组检查所有除数，如果除数减 1 满足给定条件⌊N / M⌋ = N mod M ，则增加计数。

下面是上述方法的实现：

C++

// C++ program of the above approach
 
#include 
using namespace std;
 
// Function to calculate the
// count of numbers such that it
// gives same quotient and remainder
void countDivisors(long long int n)
{
 
    int count = 0;
 
    // Stores divisor of number N.
    vector divisor;
 
    // Iterate through numbers from 2
    // to sqrt(N) and store divisors of N
    for (int i = 2; i <= sqrt(n); i++) {
 
        if (n % i == 0) {
 
            if (n / i == i)
                divisor.push_back(i);
 
            else {
 
                divisor.push_back(i);
                divisor.push_back(n / i);
            }
        }
    }
 
    // As N is also divisor of itself
    divisor.push_back(n);
 
    // Iterate through divisors
    for (auto x : divisor) {
        x -= 1;
 
        // Checking whether x satisfies the
        // required condition
        if ((n / x) == (n % x))
            count++;
    }
 
    // Print the count
    cout << count;
}
 
// Driver Code
int main()
{
    // Given N
    long long int N = 1000000000000;
 
    // Function Call
    countDivisors(N);
 
    return 0;
}

Java

// Java program of the above approach
class GFG {
     
    // Function to calculate the
    // count of numbers such that it
    // gives same quotient and remainder
    static void countDivisors(int n)
    {   
        int count = 0;
        int j = 0;
     
        // Stores divisor of number N.
        int divisor[] =  new int[n];
     
        // Iterate through numbers from 2
        // to sqrt(N) and store divisors of N
        for (int i = 2; i <= Math.sqrt(n); i++) {   
            if (n % i == 0) {
                if (n / i == i){
                    divisor[j] = i;
                     j += 1;
                }
                else {
                    divisor[j] = i;
                    divisor[j + 1] = n / i;                   
                    j += 2;
                }
            }
        }
     
        // As N is also divisor of itself
        divisor[j] = n;
     
        // Iterate through divisors
        for (int i = 0; i <= j; i++)
        {
            int x = divisor[i];
            x -= 1;
     
            // Checking whether x satisfies the
            // required condition
            if ((n / x) == (n % x))
                count++;
        }
     
        // Print the count
        System.out.print(count);
    }
     
    // Driver Code
    public static void main (String[] args)
    {
       
        // Given N
        int N = 10000000;
     
        // Function Call
        countDivisors(N);
    }
}
 
// This code is contributed by AnkThon

Python3

# Python3 program of the above approach
from math import floor, sqrt
 
# Function to calculate the
# count of numbers such that it
# gives same quotient and remainder
def countDivisors(n):
     
    count = 0
 
    # Stores divisor of number N.
    divisor = []
 
    # Iterate through numbers from 2
    # to sqrt(N) and store divisors of N
    for i in range(2, floor(sqrt(n))):
        if (n % i == 0):
            if (n // i == i):
                divisor.append(i)
            else:
                divisor.append(i)
                divisor.append(n // i)
 
    # As N is also divisor of itself
    divisor.append(n)
 
    # Iterate through divisors
    for x in divisor:
        x -= 1
 
        # Checking whether x satisfies the
        # required condition
        if ((n // x) == (n % x)):
            count += 1
 
    # Print the count
    print(count)
 
# Driver Code
if __name__ == '__main__':
     
    # Given N
    N = 1000000000000
 
    # Function Call
    countDivisors(N)
 
# This code is contributed by mohit kumar 29

C#

// C# program of the above approach
using System;
class GFG {
     
    // Function to calculate the
    // count of numbers such that it
    // gives same quotient and remainder
    static void countDivisors(int n)
    {   
        int count = 0;
        int j = 0;
     
        // Stores divisor of number N.
        int []divisor =  new int[n];
     
        // Iterate through numbers from 2
        // to sqrt(N) and store divisors of N
        for (int i = 2; i <= Math.Sqrt(n); i++) {   
            if (n % i == 0) {
                if (n / i == i){
                    divisor[j] = i;
                     j += 1;
                }
                else {
                    divisor[j] = i;
                    divisor[j + 1] = n / i;                   
                    j += 2;
                }
            }
        }
     
        // As N is also divisor of itself
        divisor[j] = n;
     
        // Iterate through divisors
        for (int i = 0; i <= j; i++)
        {
            int x = divisor[i];
            x -= 1;
     
            // Checking whether x satisfies the
            // required condition
            if ((n / x) == (n % x))
                count++;
        }
     
        // Print the count
        Console.Write(count);
    }
     
    // Driver Code
    public static void Main(String[] args)
    {
       
        // Given N
        int N = 10000000;
     
        // Function Call
        countDivisors(N);
    }
}
 
// This code contributed by shikhasingrajput

Javascript

 
// Javascript program of the above approach   
 
// Function to calculate the
    // count of numbers such that it
    // gives same quotient and remainder
    function countDivisors(n)
    {
        var count = 0;
        var j = 0;
 
        // Stores divisor of number N.
        var divisor = Array(n).fill(0);
 
        // Iterate through numbers from 2
        // to sqrt(N) and store divisors of N
        for (var i = 2; i <= Math.sqrt(n); i++)
        {
            if (n % i == 0) {
                if (parseInt(n / i) == i)
                {
                    divisor[j] = i;
                    j += 1;
                } else {
                    divisor[j] = i;
                    divisor[j + 1] = parseInt(n / i);
                    j += 2;
                }
            }
        }
 
        // As N is also divisor of itself
        divisor[j] = n;
 
        // Iterate through divisors
        for (var i = 0; i <= j; i++) {
            var x = divisor[i];
            x -= 1;
 
            // Checking whether x satisfies the
            // required condition
            if (parseInt(n / x) == parseInt(n % x))
                count++;
        }
 
        // Print the count
        document.write(count);
    }
 
    // Driver Code
     
 
        // Given N
        var N = 10000000;
 
        // Function Call
        countDivisors(N);
 
// This code contributed by aashish1995
 

输出：

84

时间复杂度： O(sqrt(N))
辅助空间： O(sqrt(N))