Minimum operations to make all elements equal using the second array

Given two arrays A[] and B[] both having N elements. Find the minimum number of operations to make all elements of A equal to the second array B. An operation comprises of:

```A[i] = A[i] - B[i], 0 <= i <= n-1
```

Note: If it’s not possible to make array elements equal print -1.
Examples:

Input: A[] = {5, 7, 10, 5, 15}, B[] = {2, 2, 1, 3, 5}
Output:
Explanation:
Following are the operations:
1) Choosing index 1 -> 5 5 10 5 15
2) Choosing index 2 -> 5 5 9 5 15
3) Choosing index 2 -> 5 5 8 5 15
4) Choosing index 2 -> 5 5 7 5 15
5) Choosing index 2 -> 5 5 6 5 15
6) Choosing index 2 -> 5 5 5 5 15
7) Choosing index 4 -> 5 5 5 5 10
8) Choosing index 4 -> 5 5 5 5 5

Input: A[] = {3, 5, 8, 2}, B[] = {1, 2, 1, 1}
Output: 12

Approach:

• It can be observed that the maximum possible value if all elements of A can be made equal is the minimum element of A.
• So we can iterate over the final value x, when all elements of A become equal. Using above observation – 0 <= x <= min(A[i]). For each x, traverse A and check whether A[i] can be made equal to x using B[i] :
```A[i] - k*B[i] = x
Take mod with B[i] on both sides
A[i] %B[i] = x %B[i]  ->
must be satisfied for A[i] to be converted to x
```

If condition is satisfied, then number of operations required for this element = (A[i] – x)/B[i]

Below is the implementation of the above approach:

 `// C++ implementation to find the ` `// minimum operations make all elements  ` `// equal using the second array ` ` `  `#include ` ` `  `using` `namespace` `std; ` ` `  `// Function to find the minimum  ` `// operations required to make ` `// all elements of the array equal ` `int` `minOperations(``int` `a[], ``int` `b[], ``int` `n) ` `{ ` `    ``// Minimum element of A[] ` `    ``int` `minA = *min_element(a, a + n); ` ` `  `    ``// Traverse through all final values ` `    ``for` `(``int` `x = minA; x >= 0; x--) { ` `         `  `        ``// Variable indicating  ` `        ``// whether all elements ` `        ``// can be converted to x or not ` `        ``bool` `check = 1; ` ` `  `        ``// Total operations ` `        ``int` `operations = 0; ` `         `  `        ``// Traverse through  ` `        ``// all array elements ` `        ``for` `(``int` `i = 0; i < n; i++) { ` `            ``if` `(x % b[i] == a[i] % b[i]) { ` `                ``operations +=  ` `                    ``(a[i] - x) / b[i]; ` `            ``} ` ` `  `            ``// All elements can't  ` `            ``// be converted to x ` `            ``else` `{ ` `                ``check = 0; ` `                ``break``; ` `            ``} ` `        ``} ` `        ``if` `(check) ` `            ``return` `operations; ` `    ``} ` `    ``return` `-1; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `N = 5; ` `    ``int` `A[N] = { 5, 7, 10, 5, 15 }; ` `    ``int` `B[N] = { 2, 2, 1, 3, 5 }; ` ` `  `    ``cout << minOperations(A, B, N); ` `    ``return` `0; ` `} `

 `// Java implementation to find the ` `// minimum operations make all elements  ` `// equal using the second array ` `import` `java.util.*; ` `class` `GFG{ ` ` `  `// Function to find the minimum  ` `// operations required to make ` `// all elements of the array equal ` `static` `int` `minOperations(``int` `a[], ``int` `b[], ``int` `n) ` `{ ` `    ``// Minimum element of A[] ` `    ``int` `minA = Arrays.stream(a).min().getAsInt(); ` ` `  `    ``// Traverse through all final values ` `    ``for` `(``int` `x = minA; x >= ``0``; x--)  ` `    ``{ ` `         `  `        ``// Variable indicating  ` `        ``// whether all elements ` `        ``// can be converted to x or not ` `        ``boolean` `check = ``true``; ` ` `  `        ``// Total operations ` `        ``int` `operations = ``0``; ` `         `  `        ``// Traverse through  ` `        ``// all array elements ` `        ``for` `(``int` `i = ``0``; i < n; i++)  ` `        ``{ ` `            ``if` `(x % b[i] == a[i] % b[i])  ` `            ``{ ` `                ``operations += (a[i] - x) / b[i]; ` `            ``} ` ` `  `            ``// All elements can't  ` `            ``// be converted to x ` `            ``else`  `            ``{ ` `                ``check = ``false``; ` `                ``break``; ` `            ``} ` `        ``} ` `        ``if` `(check) ` `            ``return` `operations; ` `    ``} ` `    ``return` `-``1``; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `N = ``5``; ` `    ``int` `A[] = { ``5``, ``7``, ``10``, ``5``, ``15` `}; ` `    ``int` `B[] = { ``2``, ``2``, ``1``, ``3``, ``5` `}; ` ` `  `    ``System.out.print(minOperations(A, B, N)); ` `} ` `} ` ` `  `// This code is contributed by AbhiThakur `

 `# Python3 implementation to find the ` `# minimum operations make all elements ` `# equal using the second array ` ` `  `# Function to find the minimum ` `# operations required to make ` `# all elements of the array equal ` `def` `minOperations(a, b, n): ` `     `  `    ``# Minimum element of A ` `    ``minA ``=` `min``(a); ` ` `  `    ``# Traverse through all final values ` `    ``for` `x ``in` `range``(minA, ``-``1``, ``-``1``): ` ` `  `        ``# Variable indicating ` `        ``# whether all elements ` `        ``# can be converted to x or not ` `        ``check ``=` `True``; ` ` `  `        ``# Total operations ` `        ``operations ``=` `0``; ` ` `  `        ``# Traverse through ` `        ``# all array elements ` `        ``for` `i ``in` `range``(n): ` `            ``if` `(x ``%` `b[i] ``=``=` `a[i] ``%` `b[i]): ` `                ``operations ``+``=` `(a[i] ``-` `x) ``/` `b[i]; ` ` `  `            ``# All elements can't ` `            ``# be converted to x ` `            ``else``: ` `                ``check ``=` `False``; ` `                ``break``; ` ` `  `        ``if` `(check): ` `            ``return` `operations; ` ` `  `    ``return` `-``1``; ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` `     `  `    ``N ``=` `5``; ` `    ``A ``=` `[ ``5``, ``7``, ``10``, ``5``, ``15` `]; ` `    ``B ``=` `[ ``2``, ``2``, ``1``, ``3``, ``5` `]; ` ` `  `    ``print``(``int``(minOperations(A, B, N))); ` ` `  `# This code is contributed by amal kumar choubey `

 `// C# implementation to find the ` `// minimum operations make all elements  ` `// equal using the second array ` `using` `System; ` `using` `System.Linq; ` ` `  `class` `GFG{ ` ` `  `// Function to find the minimum  ` `// operations required to make ` `// all elements of the array equal ` `static` `int` `minOperations(``int` `[]a, ``int` `[]b, ``int` `n) ` `{ ` `     `  `    ``// Minimum element of A[] ` `    ``int` `minA = a.Max(); ` ` `  `    ``// Traverse through all final values ` `    ``for``(``int` `x = minA; x >= 0; x--)  ` `    ``{ ` `        `  `       ``// Variable indicating  ` `       ``// whether all elements ` `       ``// can be converted to x or not ` `       ``bool` `check = ``true``; ` `        `  `       ``// Total operations ` `       ``int` `operations = 0; ` `        `  `       ``// Traverse through  ` `       ``// all array elements ` `       ``for``(``int` `i = 0; i < n; i++)  ` `       ``{ ` `          ``if` `(x % b[i] == a[i] % b[i])  ` `          ``{ ` `              ``operations += (a[i] - x) / b[i]; ` `          ``} ` `           `  `          ``// All elements can't  ` `          ``// be converted to x ` `          ``else` `          ``{ ` `              ``check = ``false``; ` `              ``break``; ` `          ``} ` `       ``} ` `       ``if` `(check) ` `           ``return` `operations; ` `    ``} ` `    ``return` `-1; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(``string``[] args) ` `{ ` `    ``int` `N = 5; ` `    ``int` `[]A = { 5, 7, 10, 5, 15 }; ` `    ``int` `[]B = { 2, 2, 1, 3, 5 }; ` ` `  `    ``Console.WriteLine(minOperations(A, B, N)); ` `} ` `} ` ` `  `// This code is contributed by SoumikMondal `

Output:
```8
```

Time Complexity: O(N * min(Ai))

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

Article Tags :