Count numbers in range 1 to N which are divisible by X but not by Y

Given two positive integers X and Y, the task is to count the total numbers in range 1 to N which are divisible by X but not Y.

Examples:

Input: x = 2, Y = 3, N = 10 Output: 4 Numbers divisible by 2 but not 3 are : 2, 4, 8, 10 Input : X = 2, Y = 4, N = 20 Output : 5 Numbers divisible by 2 but not 4 are : 2, 6, 10, 14, 18

A

Simple Solution

is to count numbers divisible by X but not Y is to loop through 1 to N and counting such number which is divisible by X but not Y.

Approach

1. For every number in range 1 to N, Increment count if the number is divisible by X but not by Y.
2. Print the count.
3. 1. Below is the implementation of above approach:
   2. C++

      // C++ implementation of above approach
      #include <bits/stdc++.h>
      using namespace std;
      
      // Function to count total numbers divisible by
      // x but not y in range 1 to N
      int countNumbers(int X, int Y, int N)
      {
          int count = 0;
          for (int i = 1; i <= N; i++) {
              // Check if Number is divisible
              // by x but not Y
              // if yes, Increment count
              if ((i % X == 0) && (i % Y != 0))
                  count++;
          }
          return count;
      }
      
      // Driver Code
      int main()
      {
      
          int X = 2, Y = 3, N = 10;
          cout << countNumbers(X, Y, N);
          return 0;
      }

      Java

      // Java implementation of above approach
      
      class GFG {
      
          // Function to count total numbers divisible by
          // x but not y in range 1 to N
          static int countNumbers(int X, int Y, int N)
          {
              int count = 0;
              for (int i = 1; i <= N; i++) {
                  // Check if Number is divisible
                  // by x but not Y
                  // if yes, Increment count
                  if ((i % X == 0) && (i % Y != 0))
                      count++;
              }
              return count;
          }
      
          // Driver Code
          public static void main(String[] args)
          {
      
              int X = 2, Y = 3, N = 10;
              System.out.println(countNumbers(X, Y, N));
          }
      }

      Python3

      # Python3 implementation of above approach
      
      # Function to count total numbers divisible
      # by x but not y in range 1 to N
      def countNumbers(X, Y, N):
      
          count = 0;
          for i in range(1, N + 1):
      
              # Check if Number is divisible
              # by x but not Y
              # if yes, Increment count
              if ((i % X == 0) and (i % Y != 0)):
                  count += 1;
      
          return count;
      
      # Driver Code
      X = 2;
      Y = 3;
      N = 10;
      print(countNumbers(X, Y, N));
      
      # This code is contributed by mits

      C#

      // C# implementation of the above approach
      using System;
      class GFG {
      
          // Function to count total numbers divisible by
          // x but not y in range 1 to N
          static int countNumbers(int X, int Y, int N)
          {
              int count = 0;
              for (int i = 1; i <= N; i++) {
                  // Check if Number is divisible
                  // by x but not Y
                  // if yes, Increment count
                  if ((i % X == 0) && (i % Y != 0))
                      count++;
              }
              return count;
          }
      
          // Driver Code
          public static void Main()
          {
      
              int X = 2, Y = 3, N = 10;
              Console.WriteLine(countNumbers(X, Y, N));
          }
      }

      Javascript

      // Function to count total numbers divisible by
      // x but not y in the range 1 to N
      function countNumbers(X, Y, N) {
          let count = 0;
          for (let i = 1; i <= N; i++) {
              // Check if the number is divisible by X but not by Y
              if (i % X === 0 && i % Y !== 0) {
                  count++;
              }
          }
          return count;
      }
      
      // Driver code
      function main() {
          const X = 2;
          const Y = 3;
          const N = 10;
      
          // Call the countNumbers function and print the result
          console.log(countNumbers(X, Y, N));
      }
      
      // Call the main function to start the process
      main();

      PHP

      <?php
      //PHP implementation of above approach
      
      // Function to count total numbers divisible by
      // x but not y in range 1 to N
      function countNumbers($X, $Y, $N)
      {
          $count = 0;
          for ($i = 1; $i <= $N; $i++)
          {
              // Check if Number is divisible
              // by x but not Y
              // if yes, Increment count
              if (($i % $X == 0) && ($i % $Y != 0))
                  $count++;
          }
          return $count;
      }
      
      // Driver Code
      $X = 2;
      $Y = 3;
      $N = 10;
      echo (countNumbers($X, $Y, $N));
      
      // This code is contributed by Arnab Kundu
      ?>
   3. Output

      4
      
      
      

   4. Time Complexity : O(N)
   5. Efficient solution:
   6. 1. In range 1 to N, find total numbers divisible by X and total numbers divisible by Y.
      2. Also, Find total numbers divisible by either X or Y
      3. Calculate total number divisible by X but not Y as (total number divisible by X or Y) – (total number divisible by Y)
   6. Below is the implementation of above approach:
   7. C++

      // C++ implementation of above approach
      #include <bits/stdc++.h>
      using namespace std;
      
      // Function to count total numbers divisible by
      // x but not y in range 1 to N
      int countNumbers(int X, int Y, int N)
      {
      
          // Count total number divisible by X
          int divisibleByX = N / X;
      
          // Count total number divisible by Y
          int divisibleByY = N / Y;
      
          // Count total number divisible by either X or Y
          int LCM = (X * Y) / __gcd(X, Y);
          int divisibleByLCM = N / LCM;
          int divisibleByXorY = divisibleByX + divisibleByY
                                           - divisibleByLCM;
      
          // Count total numbers divisible by X but not Y
          int divisibleByXnotY = divisibleByXorY
                                             - divisibleByY;
      
          return divisibleByXnotY;
      }
      
      // Driver Code
      int main()
      {
      
          int X = 2, Y = 3, N = 10;
          cout << countNumbers(X, Y, N);
          return 0;
      }

      Java

      // Java implementation of above approach
      
      class GFG {
      
          // Function to calculate GCD
      
          static int gcd(int a, int b)
          {
              if (b == 0)
                  return a;
              return gcd(b, a % b);
          }
      
          // Function to count total numbers divisible by
          // x but not y in range 1 to N
      
          static int countNumbers(int X, int Y, int N)
          {
      
              // Count total number divisible by X
              int divisibleByX = N / X;
      
              // Count total number divisible by Y
              int divisibleByY = N / Y;
      
              // Count total number divisible by either X or Y
              int LCM = (X * Y) / gcd(X, Y);
              int divisibleByLCM = N / LCM;
              int divisibleByXorY = divisibleByX + divisibleByY
                                    - divisibleByLCM;
      
              // Count total number divisible by X but not Y
              int divisibleByXnotY = divisibleByXorY
                                                - divisibleByY;
      
              return divisibleByXnotY;
          }
      
          // Driver Code
          public static void main(String[] args)
          {
      
              int X = 2, Y = 3, N = 10;
              System.out.println(countNumbers(X, Y, N));
          }
      }

      Python3

      # Python 3 implementation of above approach
      from math import gcd
      
      # Function to count total numbers divisible
      # by x but not y in range 1 to N
      def countNumbers(X, Y, N):
      
          # Count total number divisible by X
          divisibleByX = int(N / X)
      
          # Count total number divisible by Y
          divisibleByY = int(N / Y)
      
          # Count total number divisible
          # by either X or Y
          LCM = int((X * Y) / gcd(X, Y))
          divisibleByLCM = int(N / LCM)
          divisibleByXorY = (divisibleByX +
                             divisibleByY -
                             divisibleByLCM)
      
          # Count total numbers divisible by
          # X but not Y
          divisibleByXnotY = (divisibleByXorY -
                              divisibleByY)
      
          return divisibleByXnotY
      
      # Driver Code
      if __name__ == '__main__':
          X = 2
          Y = 3
          N = 10
          print(countNumbers(X, Y, N))
      
      # This code is contributed by
      # Surendra_Gangwar

      C#

      // C# implementation of above approach
      
      using System;
      class GFG {
      
          // Function to calculate GCD
          static int gcd(int a, int b)
          {
              if (b == 0)
                  return a;
              return gcd(b, a % b);
          }
      
          // Function to count total numbers divisible by
          // x but not y in range 1 to N
          static int countNumbers(int X, int Y, int N)
          {
      
              // Count total number divisible by X
              int divisibleByX = N / X;
      
              // Count total number divisible by Y
              int divisibleByY = N / Y;
      
              // Count total number divisible by either X or Y
              int LCM = (X * Y) / gcd(X, Y);
              int divisibleByLCM = N / LCM;
              int divisibleByXorY = divisibleByX + divisibleByY
                                              - divisibleByLCM;
      
              // Count total number divisible by X but not Y
              int divisibleByXnotY = divisibleByXorY
                                                - divisibleByY;
      
              return divisibleByXnotY;
          }
      
          // Driver Code
          public static void Main()
          {
      
              int X = 2, Y = 3, N = 10;
              Console.WriteLine(countNumbers(X, Y, N));
          }
      }

      Javascript

      // Function to count total numbers divisible by
      // X but not Y in the range 1 to N
      function countNumbers(X, Y, N) {
          // Count total numbers divisible by X
          const divisibleByX = Math.floor(N / X);
      
          // Count total numbers divisible by Y
          const divisibleByY = Math.floor(N / Y);
      
          // Calculate the least common multiple (LCM) of X and Y
          const LCM = (X * Y) / gcd(X, Y);
      
          // Count total numbers divisible by either X or Y
          const divisibleByLCM = Math.floor(N / LCM);
      
          // Count total numbers divisible by either X or Y
          const divisibleByXorY = divisibleByX + divisibleByY - divisibleByLCM;
      
          // Count total numbers divisible by X but not by Y
          const divisibleByXnotY = divisibleByXorY - divisibleByY;
      
          return divisibleByXnotY;
      }
      
      // Function to calculate the greatest common divisor (GCD) using Euclidean algorithm
      function gcd(a, b) {
          if (b === 0) {
              return a;
          }
          return gcd(b, a % b);
      }
      
      // Driver code
      function main() {
          const X = 2;
          const Y = 3;
          const N = 10;
      
          // Call the countNumbers function and print the result
          console.log("Count of numbers divisible by " + X + " but not by " + Y + " in the range 1 to " + N + ": " + countNumbers(X, Y, N));
      }
      
      // Call the main function to start the process
      main();

      PHP

      <?php
      // PHP implementation of above approach
      
      function __gcd($a, $b)
      {
      
          // Everything divides 0
          if ($a == 0)
              return $b;
          if ($b == 0)
              return $a;
      
          // base case
          if($a == $b)
              return $a ;
      
          // a is greater
          if($a > $b)
              return __gcd( $a - $b , $b );
      
          return __gcd( $a , $b - $a );
      }
      
      // Function to count total numbers divisible
      // by x but not y in range 1 to N
      function countNumbers($X, $Y, $N)
      {
      
          // Count total number divisible by X
          $divisibleByX = $N / $X;
      
          // Count total number divisible by Y
          $divisibleByY = $N /$Y;
      
          // Count total number divisible by either X or Y
          $LCM = ($X * $Y) / __gcd($X, $Y);
          $divisibleByLCM = $N / $LCM;
          $divisibleByXorY = $divisibleByX + $divisibleByY -
                                             $divisibleByLCM;
      
          // Count total numbers divisible by X but not Y
          $divisibleByXnotY = $divisibleByXorY -
                              $divisibleByY;
      
          return ceil($divisibleByXnotY);
      }
      
      // Driver Code
      $X = 2;
      $Y = 3;
      $N = 10;
      echo countNumbers($X, $Y, $N);
      
      // This is code contrubted by inder_verma
      ?>
   8. Output

      4
      
      
      

   9. Time Complexity:
   10. O(1)