 GeeksforGeeks App
Open App Browser
Continue

# Find the number of integers x in range (1,N) for which x and x+1 have same number of divisors

Given an integer N. The task is to find the number of integers 1 < x < N, for which x and x + 1 have the same number of positive divisors.

Examples:

Input: N = 3
Output:
Divisors(1) = 1
Divisors(2) = 1 and 2
Divisors(3) = 1 and 3
Only valid x is 2.

Input: N = 15
Output:

Approach: Find the number of divisors of all numbers below N and store them in an array. And count the number of integers x such that x and x + 1 have the same number of positive divisors by running a loop.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;``#define N 100005` `// To store number of divisors and``// Prefix sum of such numbers``int` `d[N], pre[N];` `// Function to find the number of integers``// 1 < x < N for which x and x + 1 have``// the same number of positive divisors``void` `Positive_Divisors()``{``    ``// Count the number of divisors``    ``for` `(``int` `i = 1; i < N; i++) {` `        ``// Run a loop upto sqrt(i)``        ``for` `(``int` `j = 1; j * j <= i; j++) {` `            ``// If j is divisor of i``            ``if` `(i % j == 0) {` `                ``// If it is perfect square``                ``if` `(j * j == i)``                    ``d[i]++;``                ``else``                    ``d[i] += 2;``            ``}``        ``}``    ``}` `    ``int` `ans = 0;` `    ``// x and x+1 have same number of``    ``// positive divisors``    ``for` `(``int` `i = 2; i < N; i++) {``        ``if` `(d[i] == d[i - 1])``            ``ans++;``        ``pre[i] = ans;``    ``}``}` `// Driver code``int` `main()``{``    ``// Function call``    ``Positive_Divisors();` `    ``int` `n = 15;` `    ``// Required answer``    ``cout << pre[n] << endl;` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``class` `GFG``{``    ` `static` `int` `N =``100005``;` `// To store number of divisors and``// Prefix sum of such numbers``static` `int` `d[] = ``new` `int``[N], pre[] = ``new` `int``[N];` `// Function to find the number of integers``// 1 < x < N for which x and x + 1 have``// the same number of positive divisors``static` `void` `Positive_Divisors()``{``    ``// Count the number of divisors``    ``for` `(``int` `i = ``1``; i < N; i++)``    ``{` `        ``// Run a loop upto sqrt(i)``        ``for` `(``int` `j = ``1``; j * j <= i; j++)``        ``{` `            ``// If j is divisor of i``            ``if` `(i % j == ``0``)``            ``{` `                ``// If it is perfect square``                ``if` `(j * j == i)``                    ``d[i]++;``                ``else``                    ``d[i] += ``2``;``            ``}``        ``}``    ``}` `    ``int` `ans = ``0``;` `    ``// x and x+1 have same number of``    ``// positive divisors``    ``for` `(``int` `i = ``2``; i < N; i++)``    ``{``        ``if` `(d[i] == d[i - ``1``])``            ``ans++;``        ``pre[i] = ans;``    ``}``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``// Function call``    ``Positive_Divisors();` `    ``int` `n = ``15``;` `    ``// Required answer``    ``System.out.println(pre[n]);``}``}` `/* This code contributed by PrinciRaj1992 */`

## Python3

 `# Python3 implementation of the above approach``from` `math ``import` `sqrt;` `N ``=` `100005` `# To store number of divisors and``# Prefix sum of such numbers``d ``=` `[``0``] ``*` `N``pre ``=` `[``0``] ``*` `N` `# Function to find the number of integers``# 1 < x < N for which x and x + 1 have``# the same number of positive divisors``def` `Positive_Divisors() :``    ` `    ``# Count the number of divisors``    ``for` `i ``in` `range``(N) :` `        ``# Run a loop upto sqrt(i)``        ``for` `j ``in` `range``(``1``, ``int``(sqrt(i)) ``+` `1``) :` `            ``# If j is divisor of i``            ``if` `(i ``%` `j ``=``=` `0``) :` `                ``# If it is perfect square``                ``if` `(j ``*` `j ``=``=` `i) :``                    ``d[i] ``+``=` `1``                ``else` `:``                    ``d[i] ``+``=` `2` `    ``ans ``=` `0` `    ``# x and x+1 have same number of``    ``# positive divisors``    ``for` `i ``in` `range``(``2``, N) :``        ``if` `(d[i] ``=``=` `d[i ``-` `1``]) :``            ``ans ``+``=` `1``        ``pre[i] ``=` `ans``    ` `# Driver code``if` `__name__ ``=``=` `"__main__"` `:` `    ``# Function call``    ``Positive_Divisors()` `    ``n ``=` `15` `    ``# Required answer``    ``print``(pre[n])` `# This code is contributed by Ryuga`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{``    ` `static` `int` `N =100005;` `// To store number of divisors and``// Prefix sum of such numbers``static` `int` `[]d = ``new` `int``[N];``static` `int` `[]pre = ``new` `int``[N];` `// Function to find the number of integers``// 1 < x < N for which x and x + 1 have``// the same number of positive divisors``static` `void` `Positive_Divisors()``{``    ``// Count the number of divisors``    ``for` `(``int` `i = 1; i < N; i++)``    ``{` `        ``// Run a loop upto sqrt(i)``        ``for` `(``int` `j = 1; j * j <= i; j++)``        ``{` `            ``// If j is divisor of i``            ``if` `(i % j == 0)``            ``{` `                ``// If it is perfect square``                ``if` `(j * j == i)``                    ``d[i]++;``                ``else``                    ``d[i] += 2;``            ``}``        ``}``    ``}` `    ``int` `ans = 0;` `    ``// x and x+1 have same number of``    ``// positive divisors``    ``for` `(``int` `i = 2; i < N; i++)``    ``{``        ``if` `(d[i] == d[i - 1])``            ``ans++;``        ``pre[i] = ans;``    ``}``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``// Function call``    ``Positive_Divisors();` `    ``int` `n = 15;` `    ``// Required answer``    ``Console.WriteLine(pre[n]);``}``}` `// This code has been contributed by 29AjayKumar`

## PHP

 ``

## Javascript

 ``

Output:

`2`

Time complexity: O(N3/2)

Auxiliary Space: O(N)

Approach 2:

One approach to finding the number of integers 1 < x < N for which x and x + 1 have the same number of positive divisors is to use a prime factorization method. This involves finding the prime factors of each number and using the formula for the number of divisors of a number based on its prime factorization.

Here is the step-by-step algorithm for implementing the approach:

1. Define a function Positive_Divisors() to calculate the number of positive divisors for each integer in the range [2, N).
2. In the function Positive_Divisors(), initialize an array d of size N to store the number of divisors for each integer in the range [2, N).
3. Iterate over each integer i in the range [2, N) using a loop.
4. For each integer i, calculate its prime factorization and compute the number of divisors using the formula for the number of divisors of a positive integer. Store the result in d[i].
5. Initialize a variable ans to 0 to store the final answer.
6. Iterate over each integer i in the range [2, N) using another loop.
7. For each integer i, check if d[i] == d[i – 1],   If this condition is true, then increment ans by 1.
8. Initialize an array pre of size N to store the prefix sum of the answer.
9. For each integer i in the range [2, N), set pre[i] = ans.
10. In the main() function, call the function Positive_Divisors().
11. Print the value of pre[n], where n is a given integer.

## C++

 `#include ``using` `namespace` `std;``#define N 100005` `// To store number of divisors and``// Prefix sum of such numbers``int` `d[N], pre[N];` `// Function to find the number of integers``// 1 < x < N for which x and x + 1 have``// the same number of positive divisors``void` `Positive_Divisors()``{``    ``// Count the number of divisors``    ``for` `(``int` `i = 2; i < N; i++) {``        ``int` `num = i;``        ``int` `divisors = 1;``        ``for` `(``int` `j = 2; j * j <= num; j++) {``            ``int` `count = 0;``            ``while` `(num % j == 0) {``                ``count++;``                ``num /= j;``            ``}``            ``divisors *= (count + 1);``        ``}``        ``if` `(num > 1)``            ``divisors *= 2;``        ``d[i] = divisors;``    ``}` `    ``int` `ans = 0;` `    ``// x and x+1 have same number of``    ``// positive divisors``    ``for` `(``int` `i = 2; i < N; i++) {``        ``if` `(d[i] == d[i - 1])``            ``ans++;``        ``pre[i] = ans;``    ``}``}` `// Driver code``int` `main()``{``    ``// Function call``    ``Positive_Divisors();` `    ``int` `n = 15;` `    ``// Required answer``    ``cout << pre[n] << endl;` `    ``return` `0;``}`

Output

`2`

Time Complexity: O(N log N)
Auxiliary Space: O(N)

Explaination :
The time complexity of this code is O(N log N) because calculating the prime factorization of each integer in the range [2, N) takes O(log N) time and this operation is performed for each integer in the range [2, N).

The auxiliary space complexity is O(N) because two arrays of size N are used.

My Personal Notes arrow_drop_up