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.
    1. Below is the implementation of above approach:

      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      // 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;
      }
      chevron_right
      
      
      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      // 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));
          }
      }
      chevron_right
      
      
      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      # 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
      chevron_right
      
      
      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      // 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));
          }
      }
      chevron_right
      
      
      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      <?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
      ?>
      chevron_right
      
      
      Output:
      4
      

      Time Complexity : O(N)

      Efficient solution:

      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)

      Below is the implementation of above approach:

      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      // 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;
      }
      chevron_right
      
      
      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      // 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));
          }
      }
      chevron_right
      
      
      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      # 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
      chevron_right
      
      
      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      // 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));
          }
      }
      chevron_right
      
      
      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      <?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
      ?>
      chevron_right
      
      
      Output:
      4
      

      Time Complexity: O(1)




      self motivated and passionate programmer

      If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

      Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.





Article Tags :
Practice Tags :