# Minimize operations to make minimum value of one array greater than maximum value of the other

Given two arrays **A[]** and **B[]** consisting of **N** and **M** integers, the task is to find the minimum number of operations required to make the minimum element of the array **A[]** at least the maximum element of the array **B[]** such that in each operation any array element **A[]** can be incremented by **1** or any array element **B[]** can be decremented by **1**.

**Examples:**

Input:A[] = {2, 3}, B[] = {3, 5}Output:3Explanation:

Following are the operations performed:

- Increase the value of A[1] by 1 modifies the array A[] = {3, 3}.
- Decrease the value of B[2] by 1 modifies the array B[] = {3, 4}.
- Decrease the value of B[2] by 1 modifies the array B[] = {3, 3}.
After the above operations, the minimum elements of the array A[] is 3 which is greater than or equal to the maximum element of the array B[] is 3. Therefore, the total number of operations is 3.

Input:A[] = {1, 2, 3}, B[] = {4}Output:4

**Approach:** The problem can be solved by using the **Greedy Approach**. Follow the steps below to solve the given problem:

- Sort the array
**A[]**in increasing order. - Sort the array
**B[]**in decreasing order. - Traverse both of the arrays
**while A[i] < B[i]**, in order to make all elements of the arrays**A[]**and**B[]**, till index**i**, equal, say**x**, then the total number of operations is given by:

=>

(B[0] + B[1] + … + B[i]) – i*x + (A[0] + A[1] + … + A[i]) + i*x

=>(B[0] – A[0]) + (B[1] – A[1]) + … + (B[i] – A[i]).

- Traverse both the arrays until the value of
**A[i]**is smaller than**B[i]**, and the value of**(B[i] – A[i])**to the variable, say**ans**. - After completing the above steps, print the value of
**ans**as the minimum number of operations required.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `#define ll long long` `// Comparator function` `bool` `cmp(ll a, ll b) { ` `return` `a > b; }` `// Function to find the minimum number` `// of operation required to satisfy the` `// given conditions` `int` `FindMinMoves(vector<ll> A, vector<ll> B)` `{` ` ` `int` `n, m;` ` ` `n = A.size();` ` ` `m = B.size();` ` ` `// sort the array A and B in the` ` ` `// ascending and descending order` ` ` `sort(A.begin(), A.end());` ` ` `sort(B.begin(), B.end(), cmp);` ` ` `ll ans = 0;` ` ` `// Iterate over both the arrays` ` ` `for` `(` `int` `i = 0; i < min(m, n)` ` ` `&& A[i] < B[i];` ` ` `++i) {` ` ` `// Add the difference to the` ` ` `// variable answer` ` ` `ans += (B[i] - A[i]);` ` ` `}` ` ` `// Return the resultant operations` ` ` `return` `ans;` `}` `// Driver Code` `int` `main()` `{` ` ` `vector<ll> A = { 2, 3 };` ` ` `vector<ll> B = { 3, 5 };` ` ` `cout << FindMinMoves(A, B);` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.util.Arrays;` `class` `GFG{` ` ` `// Comparator function` `public` `static` `boolean` `cmp(` `int` `a, ` `int` `b)` `{` ` ` `return` `a > b;` `}` `// Function to find the minimum number` `// of operation required to satisfy the` `// given conditions` `public` `static` `int` `FindMinMoves(` `int` `[] A, ` `int` `[] B)` `{` ` ` `int` `n, m;` ` ` `n = A.length;` ` ` `m = B.length;` ` ` `// Sort the array A and B in the` ` ` `// ascending and descending order` ` ` `Arrays.sort(A);` ` ` `Arrays.sort(B);` ` ` `int` `ans = ` `0` `;` ` ` `// Iterate over both the arrays` ` ` `for` `(` `int` `i = ` `0` `;` ` ` `i < Math.min(m, n) && A[i] < B[i]; ++i)` ` ` `{` ` ` ` ` `// Add the difference to the` ` ` `// variable answer` ` ` `ans += (B[i] - A[i]);` ` ` `}` ` ` `// Return the resultant operations` ` ` `return` `ans;` `}` `// Driver Code` `public` `static` `void` `main(String args[])` `{` ` ` `int` `[] A = { ` `2` `, ` `3` `};` ` ` `int` `[] B = { ` `3` `, ` `5` `};` ` ` ` ` `System.out.println(FindMinMoves(A, B));` `}` `}` `// This code is contributed by _saurabh_jaiswal` |

## Python3

`# Python3 program for the above approach` `# Function to find the minimum number` `# of operation required to satisfy the` `# given conditions` `def` `FindMinMoves(A, B):` ` ` ` ` `n ` `=` `len` `(A)` ` ` `m ` `=` `len` `(B)` ` ` `# sort the array A and B in the` ` ` `# ascending and descending order` ` ` `A.sort()` ` ` `B.sort(reverse ` `=` `True` `)` ` ` `ans ` `=` `0` ` ` `# Iterate over both the arrays` ` ` `i ` `=` `0` ` ` ` ` `for` `i ` `in` `range` `(` `min` `(m, n) ` `and` `A[i] < B[i]):` ` ` `# Add the difference to the` ` ` `# variable answer` ` ` `ans ` `+` `=` `(B[i] ` `-` `A[i])` ` ` `# Return the resultant operations` ` ` `return` `ans` `# Driver Code` `A ` `=` `[ ` `2` `, ` `3` `]` `B ` `=` `[ ` `3` `, ` `5` `]` `print` `(FindMinMoves(A, B))` `# This code is contributed by gfgking` |

## C#

`// C# program for the above approach` `using` `System;` `class` `GFG{` `// Comparator function` `public` `static` `bool` `cmp(` `int` `a, ` `int` `b)` `{` ` ` `return` `a > b;` `}` `// Function to find the minimum number` `// of operation required to satisfy the` `// given conditions` `public` `static` `int` `FindMinMoves(` `int` `[] A, ` `int` `[] B)` `{` ` ` `int` `n, m;` ` ` `n = A.Length;` ` ` `m = B.Length;` ` ` `// Sort the array A and B in the` ` ` `// ascending and descending order` ` ` `Array.Sort(A);` ` ` `Array.Sort(B);` ` ` `int` `ans = 0;` ` ` `// Iterate over both the arrays` ` ` `for` `(` `int` `i = 0;` ` ` `i < Math.Min(m, n) && A[i] < B[i]; ++i)` ` ` `{` ` ` ` ` `// Add the difference to the` ` ` `// variable answer` ` ` `ans += (B[i] - A[i]);` ` ` `}` ` ` `// Return the resultant operations` ` ` `return` `ans;` `}` `// Driver Code` `public` `static` `void` `Main()` `{` ` ` `int` `[] A = { 2, 3 };` ` ` `int` `[] B = { 3, 5 };` ` ` ` ` `Console.Write(FindMinMoves(A, B));` `}` `}` `// This code is contributed by target_2.` |

## Javascript

`<script>` ` ` `// JavaScript program for the above approach` ` ` `// Function to find the minimum number` ` ` `// of operation required to satisfy the` ` ` `// given conditions` ` ` `function` `FindMinMoves(A, B)` ` ` `{` ` ` `let n, m;` ` ` `n = A.length;` ` ` `m = B.length;` ` ` `// sort the array A and B in the` ` ` `// ascending and descending order` ` ` `A.sort(` `function` `(a, b) { ` `return` `a - b; });` ` ` `B.sort(` `function` `(a, b) { ` `return` `b - a; });` ` ` `let ans = 0;` ` ` `// Iterate over both the arrays` ` ` `for` `(let i = 0; i < Math.min(m, n)` ` ` `&& A[i] < B[i];` ` ` `++i) {` ` ` `// Add the difference to the` ` ` `// variable answer` ` ` `ans += (B[i] - A[i]);` ` ` `}` ` ` `// Return the resultant operations` ` ` `return` `ans;` ` ` `}` ` ` `// Driver Code` ` ` `let A = [2, 3];` ` ` `let B = [3, 5];` ` ` `document.write(FindMinMoves(A, B));` ` ` `// This code is contributed by Potta Lokesh` ` ` `</script>` |

**Output:**

3

**Time Complexity:** O(K*log K), where the value of K is max(N, M).**Auxiliary Space:** O(1)

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**.