# Minimum operations to make all elements equal using the second array

• Last Updated : 10 Nov, 2021

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++

 `// 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

 `// 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

 `# 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#

 `// 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`

## Javascript

 ``

Output:

`8`

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

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up