# Number of array elements derivable from D after performing certain operations

Given an array of N integers and 3 integers D, A and B. The task is to find the number of array elements that we can convert D into by performing the following operations on D:

• Subtract A (-A)
• Subtract B (-B)

Note: It is allowed to perform any number of operations of any type.

Examples:

```Input :  arr = {1, 2, 3}, D = 6, A = 3, B = 2
Output :  3
Explanation:
We can derive 1 from D by performing (6 - 3(A) - 2(B))
We can derive 2 from D by performing (6 - 2(A) - 2(A))
We can derive 3 from D by performing (6 - 3(A))
Thus, All array elements can be derived from D.

Input :  arr = {1, 2, 3}, D = 7, A = 4, B = 2
Output :  2
Explanation:
We can derive 1 from D by performing (7 - 4(A) - 2(B))
We can derive 3 from D by performing (7 - 4(A))
Thus, we can derive {1, 3}
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Lets say the we want to check if the element ai can be derived from D:

Suppose we perform:

• The operation of type1(i.e Add A) P times.
• The operation of type 2(i.e Subtract A) Q times.
• The operation of type 3(i.e Add B) R times.
• The operation of type 4(i.e Subtract B) S times.

Let the value we get after performing these operations be X, then,
-> X = P*A – Q*A + R*B – S*B
-> X = (P – Q) * A + (R – S) * B

Suppose we successfully derive Ai from D, i.e X = |Ai – D|,

-> |Ai – D| = (P – Q) * A + (R – S) * B

Let (P – Q) = some constant say, U
and similarly let (R – S) be a constant, V

-> |Ai – D| = U * A + V * B

This is in the form of the Linear Diophantine Equation and the solution exists only when |Ai – D| is divisible by gcd(A, B).

Thus now we can simply iterate over the array and count all such Ai for which |Ai – D| is divisible by gcd(a, b).

Below is the implementation of the above approach:

## C++

 `// CPP program to find the number of array elements ` `// which can be derived by perming (+A, -A, +B, -B) ` `// operations on D ` `#include ` ` `  `using` `namespace` `std; ` ` `  `// Function to return ` `// gcd of a and b ` `int` `gcd(``int` `a, ``int` `b) ` `{ ` `    ``if` `(a == 0) ` `        ``return` `b; ` `    ``return` `gcd(b % a, a); ` `} ` ` `  `/* Function to Return the number of elements ` `   ``of arr[] which can be derived from D by  ` `   ``performing (+A, -A, +B, -B) */` `int` `findPossibleDerivables(``int` `arr[], ``int` `n, ``int` `D,  ` `                                      ``int` `A, ``int` `B) ` `{ ` `    ``// find the gcd of A and B ` `    ``int` `gcdAB = gcd(A, B); ` ` `  `    ``// counter stores the number of  ` `    ``// array elements which ` `    ``// can be derived from D ` `    ``int` `counter = 0; ` ` `  `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``// arr[i] can be derived from D only if ` `        ``// |arr[i] - D| is divisible by gcd of A and B ` `        ``if` `((``abs``(arr[i] - D) % gcdAB) == 0) { ` `            ``counter++; ` `        ``} ` `    ``} ` ` `  `    ``return` `counter; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 1, 2, 3, 4, 7, 13 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``int` `D = 5, A = 4, B = 2; ` `    ``cout << findPossibleDerivables(arr, n, D, A, B) <<``"\n"``; ` ` `  `    ``int` `a[] = { 1, 2, 3 }; ` `    ``n = ``sizeof``(a) / ``sizeof``(a); ` `    ``D = 6, A = 3, B = 2; ` `    ``cout << findPossibleDerivables(a, n, D, A, B) <<``"\n"``; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java  program to find the number of array elements ` `// which can be derived by perming (+A, -A, +B, -B) ` `// operations on D ` ` `  `import` `java.io.*; ` ` `  `class` `GFG { ` `     `  ` `  ` `  `// Function to return ` `// gcd of a and b ` ` ``static` `int` `gcd(``int` `a, ``int` `b) ` `{ ` `    ``if` `(a == ``0``) ` `        ``return` `b; ` `    ``return` `gcd(b % a, a); ` `} ` ` `  `/* Function to Return the number of elements ` `of arr[] which can be derived from D by  ` `performing (+A, -A, +B, -B) */` `static` `int` `findPossibleDerivables(``int` `arr[], ``int` `n, ``int` `D,  ` `                                    ``int` `A, ``int` `B) ` `{ ` `    ``// find the gcd of A and B ` `    ``int` `gcdAB = gcd(A, B); ` ` `  `    ``// counter stores the number of  ` `    ``// array elements which ` `    ``// can be derived from D ` `    ``int` `counter = ``0``; ` ` `  `    ``for` `(``int` `i = ``0``; i < n; i++) { ` `        ``// arr[i] can be derived from D only if ` `        ``// |arr[i] - D| is divisible by gcd of A and B ` `        ``if` `((Math.abs(arr[i] - D) % gcdAB) == ``0``) { ` `            ``counter++; ` `        ``} ` `    ``} ` ` `  `    ``return` `counter; ` `} ` ` `  `// Driver Code ` ` `  `    ``public` `static` `void` `main (String[] args) { ` `            ``int` `arr[] = { ``1``, ``2``, ``3``, ``4``, ``7``, ``13` `}; ` `    ``int` `n = arr.length; ` `    ``int` `D = ``5``, A = ``4``, B = ``2``; ` `    ``System.out.println( findPossibleDerivables(arr, n, D, A, B)); ` ` `  `    ``int` `a[] = { ``1``, ``2``, ``3` `}; ` `    ``n = a.length; ` `    ``D = ``6``; ` `    ``A = ``3``; ` `    ``B = ``2``; ` `    ``System.out.println( findPossibleDerivables(a, n, D, A, B)); ` `    ``} ` `} ` `// This code is contributed by anuj_67.. `

## Python3

 `# Python3 program to find the number of array  ` `# elements which can be derived by perming  ` `# (+A, -A, +B, -B) operations on D  ` ` `  `# Function to return gcd of a and b  ` `def` `gcd(a, b) : ` `     `  `    ``if` `(a ``=``=` `0``) : ` `        ``return` `b ` `         `  `    ``return` `gcd(b ``%` `a, a);  ` ` `  `""" Function to Return the number of elements  ` `of arr[] which can be derived from D by  ` `performing (+A, -A, +B, -B) """` `def` `findPossibleDerivables(arr, n, D, A, B) : ` ` `  `    ``# find the gcd of A and B  ` `    ``gcdAB ``=` `gcd(A, B) ` `     `  `    ``# counter stores the number of  ` `    ``# array elements which  ` `    ``# can be derived from D  ` `    ``counter ``=` `0` ` `  `    ``for` `i ``in` `range``(n) : ` `         `  `        ``# arr[i] can be derived from D only  ` `        ``# if |arr[i] - D| is divisible by  ` `        ``# gcd of A and B  ` `        ``if` `((``abs``(arr[i] ``-` `D) ``%` `gcdAB) ``=``=` `0``) : ` `            ``counter ``+``=` `1` ` `  `    ``return` `counter ` ` `  `# Driver Code  ` `if` `__name__ ``=``=` `"__main__"` `:  ` `     `  `    ``arr ``=` `[ ``1``, ``2``, ``3``, ``4``, ``7``, ``13` `]  ` `    ``n ``=` `len``(arr) ` `    ``D, A, B ``=` `5``, ``4``, ``2` `     `  `    ``print``(findPossibleDerivables(arr, n, D, A, B)) ` ` `  `    ``a ``=` `[ ``1``, ``2``, ``3` `] ` `    ``n ``=` `len``(a) ` `    ``D, A, B ``=` `6``, ``3``, ``2` `     `  `    ``print``(findPossibleDerivables(a, n, D, A, B)) ` ` `  `# This code is contributed by Ryuga `

## C#

 `// C# program to find the number of array elements ` `// which can be derived by perming (+A, -A, +B, -B) ` `// operations on D  ` `using` `System;     ` `public` `class` `GFG { ` ` `  `    ``// Function to return ` `    ``// gcd of a and b ` `     ``static` `int` `gcd(``int` `a, ``int` `b) ` `    ``{ ` `        ``if` `(a == 0) ` `            ``return` `b; ` `        ``return` `gcd(b % a, a); ` `    ``} ` ` `  `    ``/* Function to Return the number of elements ` `    ``of arr[] which can be derived from D by  ` `    ``performing (+A, -A, +B, -B) */` `    ``static` `int` `findPossibleDerivables(``int` `[]arr, ``int` `n, ``int` `D,  ` `                                        ``int` `A, ``int` `B) ` `    ``{ ` `        ``// find the gcd of A and B ` `        ``int` `gcdAB = gcd(A, B); ` ` `  `        ``// counter stores the number of  ` `        ``// array elements which ` `        ``// can be derived from D ` `        ``int` `counter = 0; ` ` `  `        ``for` `(``int` `i = 0; i < n; i++) { ` `            ``// arr[i] can be derived from D only if ` `            ``// |arr[i] - D| is divisible by gcd of A and B ` `            ``if` `((Math.Abs(arr[i] - D) % gcdAB) == 0) { ` `                ``counter++; ` `            ``} ` `        ``} ` ` `  `        ``return` `counter; ` `    ``} ` ` `  `    ``// Driver Code ` `  `  `    ``public` `static` `void` `Main () { ` `            ``int` `[]arr = { 1, 2, 3, 4, 7, 13 }; ` `    ``int` `n = arr.Length; ` `    ``int` `D = 5, A = 4, B = 2; ` `    ``Console.WriteLine( findPossibleDerivables(arr, n, D, A, B)); ` `  `  `    ``int` `[]a = { 1, 2, 3 }; ` `    ``n = a.Length; ` `    ``D = 6; ` `    ``A = 3; ` `    ``B = 2; ` `    ``Console.WriteLine( findPossibleDerivables(a, n, D, A, B)); ` `    ``} ` `} ` `// This code is contributed by 29AjayKumar `

## PHP

 ` `

Output:

```4
3
```

Time Complexity: O(N), where N is the number of array elements.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.

5

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.