Related Articles

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

• Last Updated : 22 Apr, 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))

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up