Open In App
Related Articles

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

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

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:
    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:
      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)


Last Updated : 16 Oct, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads