Skip to content
Related Articles

Related Articles

Improve Article

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: 8 
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 <bits/stdc++.h>
 
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



<script>
// javascript 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
    function minOperations(a , b , n)
    {
     
        // Minimum element of A
        var minA = Math.max.apply(Math,a);;
 
        // Traverse through all final values
        for (x = minA; x >= 0; x--) {
 
            // Variable indicating
            // whether all elements
            // can be converted to x or not
            var check = true;
 
            // Total operations
            var operations = 0;
 
            // Traverse through
            // all array elements
            for (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
        var N = 5;
        var A = [ 5, 7, 10, 5, 15 ];
        var B = [ 2, 2, 1, 3, 5 ];
 
        document.write(minOperations(A, B, N));
 
// This code is contributed by Rajput-Ji
</script>
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
Previous
Pipelined architecture with its diagram
Next

Find two numbers made up of a given digit such that their difference is divisible by N
Recommended Articles
Page :
Make all array elements equal by repeatedly replacing largest array element with the second smallest element
14, Jul 21
Minimum Cost to make all array elements equal using given operations
22, May 20
Make all array elements equal to 0 by replacing minimum subsequences consisting of equal elements
13, Jan 21
Minimum operations required to make all the array elements equal
25, Jan 19
Find the minimum number of operations required to make all array elements equal
05, Apr 19
Minimum operations required to make all elements in an array of first N odd numbers equal
07, May 21
Minimum number of increment-other operations to make all array elements equal.
05, Oct 17
Minimum operations required to make all elements of Array less than equal to 0
05, Jul 21
Minimum increment by k operations to make all elements equal
04, Mar 18
Minimum sum of values subtracted from array elements to make all array elements equal
18, Dec 20
Make all array elements equal by reducing array elements to half minimum number of times
31, Jan 21
Minimum number of bits of array elements required to be flipped to make all array elements equal
19, Apr 21
Minimum Bitwise OR operations to make any two array elements equal
12, Jul 19
Minimum Bitwise XOR operations to make any two array elements equal
23, Jul 19
Minimum decrement operations to make Array elements equal by only decreasing K each time
04, Feb 20
Make the array elements equal by performing given operations minimum number of times
27, Jan 21
Minimum Bitwise AND operations to make any two array elements equal
30, Oct 18
Find the number of operations required to make all array elements Equal
24, Jun 18
Find if it is possible to make all elements of an array equal by the given operations
30, Mar 20
Count of operations to make all elements of array a[] equal to its min element by performing a[i] – b[i]
19, May 20
Minimize count of given operations required to be performed to make all array elements equal to 1
13, Jan 21
Minimum increment and decrement by K of each pair elements required to make all array elements equal
31, Jan 21
Minimum increment operations to make K elements equal
17, Sep 19
Minimum gcd operations to make all array elements one
19, Nov 17
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
king_tsar
@king_tsar
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox