# Count of integers up to N which are non divisors and non coprime with N

• Last Updated : 02 Dec, 2021

Given an integer N, the task is to find the count of all possible integers less than N satisfying the following properties:

• The number is not coprime with N i.e their GCD is greater than 1.
• The number is not a divisor of N.

Examples:

Input: N = 10
Output:
Explanation:
All possible integers which are less than 10 and are neither divisors nor coprime with 10, are {4, 6, 8}.
Therefore, the required count is 3.
Input: N = 42
Output: 23

Approach:
Follow the steps below to solve the problem:

Total count = N – Euler’s totient(N) – Divisor count(N)

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement``// the above approach``#include ``using` `namespace` `std;` `// Function to return the count``// of integers less than N``// satisfying given conditions``int` `count(``int` `n)``{``    ``// Stores Euler counts``    ``int` `phi[n + 1] = { 0 };` `    ``// Store Divisor counts``    ``int` `divs[n + 1] = { 0 };` `    ``// Based on Sieve of Eratosthenes``    ``for` `(``int` `i = 1; i <= n; i++) {` `        ``phi[i] += i;` `        ``// Update phi values of all``        ``// multiples of i``        ``for` `(``int` `j = i * 2; j <= n; j += i)``            ``phi[j] -= phi[i];` `        ``// Update count of divisors``        ``for` `(``int` `j = i; j <= n; j += i)``            ``divs[j]++;``    ``}` `    ``// Return the final count``    ``return` `(n - phi[n] - divs[n] + 1);``}` `// Driver Code``int` `main()``{` `    ``int` `N = 42;` `    ``cout << count(N);``    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``import` `java.util.Arrays;` `class` `GFG{``    ` `// Function to return the count``// of integers less than N``// satisfying given conditions``public` `static` `int` `count(``int` `n)``{``    ` `    ``// Stores Euler counts``    ``int` `[]phi = ``new` `int``[n + ``1``];``    ``Arrays.fill(phi, ``0``);` `    ``// Store Divisor counts``    ``int` `[]divs = ``new` `int``[n + ``1``];``    ``Arrays.fill(divs, ``0``);``    ` `    ``// Based on Sieve of Eratosthenes``    ``for``(``int` `i = ``1``; i <= n; i++)``    ``{``        ``phi[i] += i;` `        ``// Update phi values of all``        ``// multiples of i``        ``for``(``int` `j = i * ``2``; j <= n; j += i)``            ``phi[j] -= phi[i];` `        ``// Update count of divisors``        ``for``(``int` `j = i; j <= n; j += i)``            ``divs[j]++;``    ``}` `    ``// Return the final count``    ``return` `(n - phi[n] - divs[n] + ``1``);``}` `// Driver Code``public` `static` `void` `main(String []args)``{``    ``int` `N = ``42``;` `    ``System.out.println(count(N));``}``}` `// This code is contributed by grand_master`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to return the count``# of integers less than N``# satisfying given conditions``def` `count(n):``    ` `    ``# Stores Euler counts``    ``phi ``=` `[``0``] ``*` `(n ``+` `1``)``    ` `    ``# Store Divisor counts``    ``divs ``=` `[``0``] ``*` `(n ``+` `1``)``    ` `    ``# Based on Sieve of Eratosthenes``    ``for` `i ``in` `range``(``1``, n ``+` `1``):``        ``phi[i] ``+``=` `i``        ` `        ``# Update phi values of all``        ``# multiples of i``        ``for` `j ``in` `range``(i ``*` `2``, n ``+` `1``, i):``            ``phi[j] ``-``=` `phi[i];` `        ``# Update count of divisors``        ``for` `j ``in` `range``(i, n ``+` `1``, i):``            ``divs[j] ``+``=` `1``            ` `    ``# Return the final count``    ``return` `(n ``-` `phi[n] ``-` `divs[n] ``+` `1``);``    ` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``N ``=` `42``    ` `    ``print``(count(N))` `# This code is contributed by jana_sayantan`

## C#

 `// C# program to implement``// the above approach``using` `System;` `class` `GFG{``    ` `// Function to return the count``// of integers less than N``// satisfying given conditions``public` `static` `int` `count(``int` `n)``{``    ` `    ``// Stores Euler counts``    ``int` `[]phi = ``new` `int``[n + 1];``    ` `    ``// Store Divisor counts``    ``int` `[]divs = ``new` `int``[n + 1];``    ` `    ``// Based on Sieve of Eratosthenes``    ``for``(``int` `i = 1; i <= n; i++)``    ``{``        ``phi[i] += i;` `        ``// Update phi values of all``        ``// multiples of i``        ``for``(``int` `j = i * 2; j <= n; j += i)``            ``phi[j] -= phi[i];` `        ``// Update count of divisors``        ``for``(``int` `j = i; j <= n; j += i)``            ``divs[j]++;``    ``}` `    ``// Return the final count``    ``return` `(n - phi[n] - divs[n] + 1);``}` `// Driver Code``public` `static` `void` `Main(String []args)``{``    ``int` `N = 42;` `    ``Console.WriteLine(count(N));``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`23`

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

My Personal Notes arrow_drop_up