# Count numbers up to C that can be reduced to 0 by adding or subtracting A or B

Given three non-negative integers A, B, and C, the task is to count the numbers in the range [1, C] that can be reduced to 0 by adding or subtracting A or B.

Examples:

Input: A = 2, B = 4, C = 7
Output: 3
Explanation: The numbers from the range [1, 7] that can be reduced to 0 by given operations are:

1. For element 2: The number can be modified as 2 – 2 = 0.
2. For element 4: The number can be modified as 4 – 2 – 2 = 0.
3. For element 6: The number can be modified as 6 – 4 – 2 = 0.

Therefore, the total count is 3.

Input: A = 2, B = 3, C = 5
Output: 5

Approach: The given problem can be solved based on the following observations:

• Consider X and Y number of addition or subtraction of A and B are performed respectively.
• After applying the operations on any number N, it becomes Ax + By. Therefore, by Extended Euclidean Algorithm, it can be said that there exist integer coefficients x and y such that Ax + By = GCD(A, B).
• Therefore, N must be a multiple of GCD(A, B), say G. Now the problem is reduced to finding the number of multiples of G which are in the range [1, C] which is floor (C / G).

Follow the below steps to solve the problem:

• Find the GCD of A and B and store it in a variable, say G.
• Now, the count of numbers over the range [1, C] is the multiples of G having values at most C which is given by floor(C/G).

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to calculate GCD of the` `// two numbers a and b` `long` `long` `gcd(``long` `long` `a, ``long` `long` `b)` `{` `    ``// Base Case` `    ``if` `(b == 0)` `        ``return` `a;`   `    ``// Recursively find the GCD` `    ``return` `gcd(b, a % b);` `}`   `// Function to count the numbers up` `// to C that can be reduced to 0 by` `// adding or subtracting A or B` `void` `countDistinctNumbers(``long` `long` `A,` `                          ``long` `long` `B,` `                          ``long` `long` `C)` `{` `    ``// Stores GCD of A and B` `    ``long` `long` `g = gcd(A, B);`   `    ``// Stores the count of multiples` `    ``// of g in the range (0, C]` `    ``long` `long` `count = C / g;`   `    ``// Print the result` `    ``cout << count;` `}`     `// Driver Code` `int` `main()` `{` `    ``long` `long` `A = 2, B = 3, C = 5;` `    ``countDistinctNumbers(A, B, C);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `class` `GFG{`   `// Function to calculate GCD of the` `// two numbers a and b` `static` `long` `gcd(``long` `a, ``long` `b)` `{` `    `  `    ``// Base Case` `    ``if` `(b == ``0``)` `        ``return` `a;`   `    ``// Recursively find the GCD` `    ``return` `gcd(b, a % b);` `}`   `// Function to count the numbers up` `// to C that can be reduced to 0 by` `// adding or subtracting A or B` `static` `void` `countDistinctNumbers(``long` `A, ``long` `B, ` `                                 ``long` `C)` `{` `    `  `    ``// Stores GCD of A and B` `    ``long` `g = gcd(A, B);`   `    ``// Stores the count of multiples` `    ``// of g in the range (0, C]` `    ``long` `count = C / g;`   `    ``// Print the result` `    ``System.out.println(count);` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``long` `A = ``2``, B = ``3``, C = ``5``;` `    `  `    ``countDistinctNumbers(A, B, C);` `}` `}`   `// This code is contributed by abhinavjain194`

## Python3

 `# Python3 program for the above approach`   `# Function to calculate GCD of the` `# two numbers a and b` `def` `gcd(a, b):` `    `  `    ``# Base Case` `    ``if` `(b ``=``=` `0``):` `        ``return` `a` `        `  `    ``# Recursively find the GCD` `    ``return` `gcd(b, a ``%` `b)`   `# Function to count the numbers up` `# to C that can be reduced to 0 by` `# adding or subtracting A or B` `def` `countDistinctNumbers(A, B, C):` `    `  `    ``# Stores GCD of A and B` `    ``g ``=` `gcd(A, B)` `    `  `    ``# Stores the count of multiples` `    ``# of g in the range (0, C]` `    ``count ``=` `C ``/``/` `g` ` `  `    ``# Print the result` `    ``print``(count)`   `# Driver code` `A ``=` `2` `B ``=` `3` `C ``=` `5`   `countDistinctNumbers(A, B, C)`   `# This code is contributed by abhinavjain194`

## C#

 `// C# program for the above approach` `using` `System;`   `class` `GFG{` `    `  `// Function to calculate GCD of the` `// two numbers a and b` `static` `long` `gcd(``long` `a, ``long` `b)` `{` `    `  `    ``// Base Case` `    ``if` `(b == 0)` `        ``return` `a;`   `    ``// Recursively find the GCD` `    ``return` `gcd(b, a % b);` `}`   `// Function to count the numbers up` `// to C that can be reduced to 0 by` `// adding or subtracting A or B` `static` `void` `countDistinctNumbers(``long` `A, ``long` `B,` `                                 ``long` `C)` `{` `    `  `    ``// Stores GCD of A and B` `    ``long` `g = gcd(A, B);`   `    ``// Stores the count of multiples` `    ``// of g in the range (0, C]` `    ``long` `count = C / g;`   `    ``// Print the result` `    ``Console.Write(count);` `}`   `// Driver Code` `static` `void` `Main()` `{` `    ``long` `A = 2, B = 3, C = 5;` `    ``countDistinctNumbers(A, B, C);` `}` `}`   `// This code is contributed by abhinavjain194`

## Javascript

 ``

Output:

`5`

Time Complexity: O(log(min(A, B)))
Auxiliary Space: O(1)