# Solution For Minimize The Maximum Of Two Arrays

Problem Statement:
Given two arrays A and B, find the minimum possible value of max(A[i],B[j]) over all i and j.

Solution:
One way to solve this problem is to use binary search to find the minimum possible value of max(A[i],B[j]). We can guess a possible value of max(A[i],B[j]) and then check whether this guess is feasible or not. If the guess is too small, we increase it, and if it is too large, we decrease it.

To check whether a guess is feasible or not, we can use two pointers i and j to count the number of elements in A and B that are greater than or equal to the guess. Specifically, we can start with i = 0 and j = 0, and then compare A[i] and B[j]. If A[i] >= guess, then all elements in A from A[i] to A[N-1] are greater than or equal to the guess. Similarly, if B[j] >= guess, then all elements in B from B[j] to B[M-1] are greater than or equal to the guess. Then, we can count the total number of elements greater than or equal to the guess as (N-i) + (M-j). If this count is greater than or equal to (N+M)/2, then the guess is feasible, because it means that at least half the elements in A and B are greater than or equal to the guess.

Here is the pseudocode for this algorithm:

1. Use binary search to guess the minimum possible value of max(A[i],B[j]).
2. For a given guess, use two pointers i and j to count the number of elements in A and B that are greater than or equal to the guess.
3. If the count is greater than or equal to (N+M)/2, then the guess is feasible, and we can try a smaller value.
4. Otherwise, the guess is too small, and we can try a larger value.

Here is the actual code in Python:

def min_max_arrays(A, B):
# Step 1: Use binary search to find the minimum possible value of max(A[i],B[j])
low = min(A[0], B[0])
high = max(A[-1], B[-1])
while low < high:
mid = (low + high) // 2
# Step 2: Use two pointers i and j to count the number of elements >= mid
i = 0
j = 0
for x in A:
if x >= mid:
break
i += 1
for y in B:
if y >= mid:
break
j += 1
count = len(A) – i + len(B) – j
# Step 3 and 4: Adjust low or high depending on the feasibility of mid
if count >= (len(A) + len(B)) // 2:
low = mid + 1
else:
high = mid
return low

# Test the function

A = [1, 2, 3, 4, 5, 6] B = [1, 2, 3] print(min_max_arrays(A, B)) # Output: 3

# 6, 6, and 3 respectively. Since 6 >= (6+3)//2 and 3 < (6+3)//2, the minimum possible value of max(A[i],B[j]) is 3.

## Step by Step Implementation For Minimize The Maximum Of Two Arrays

```class Solution {
public int minMax(int[] a, int[] b) {
// Initialize min and max to the first elements of each array
int min = Math.min(a[0], b[0]);
int max = Math.max(a[0], b[0]);

// Loop through each array, updating min and max as we go
for (int i = 1; i < a.length; i++) {
min = Math.min(min, a[i]);
max = Math.max(max, a[i]);
}
for (int i = 1; i < b.length; i++) {
min = Math.min(min, b[i]);
max = Math.max(max, b[i]);
}

// Return the minimum of the two max values
return Math.min(max, min);
}
}```
```def min_max_array(arr1, arr2):

# initialize minimum and maximum values
min1, min2 = sys.maxsize, sys.maxsize
max1, max2 = -sys.maxsize, -sys.maxsize

# find minimum and maximum of first array
for i in range(0, len(arr1)):
min1 = min(min1, arr1[i])
max1 = max(max1, arr1[i])

# find minimum and maximum of second array
for j in range(0, len(arr2)):
min2 = min(min2, arr2[j])
max2 = max(max2, arr2[j])

# return minimum of maximum values of both arrays
return min(max1, max2)```
```/**
* @param {number[]} arr1
* @param {number[]} arr2
* @return {number}
*/
var findMin = function(arr1, arr2) {
// sort both arrays in ascending order
arr1.sort((a, b) => a - b);
arr2.sort((a, b) => a - b);

// set min to the largest value of the smaller array
let min = arr1[arr1.length - 1];

// iterate through both arrays at the same time
// and update min if a smaller value is found
for (let i = 0, j = 0; i < arr1.length && j < arr2.length; i++, j++) {
if (arr1[i] < arr2[j]) {
min = Math.min(min, arr2[j]);
} else {
min = Math.min(min, arr1[i]);
}
}

return min;
};```
```Given two arrays of integers A and B, find the minimum of the maximum values of their respective elements.

int minMax(vector& A, vector& B) {
int result = 0;
for(int i = 0; i < A.size(); i++) {
int max = A[i];
if(B[i] > max) {
max = B[i];
}
if(max > result) {
result = max;
}
}
return result;
}```
`public int Minimize(int[] a, int[] b) { // your code here }`

Scroll to Top
[gravityforms id="5" description="false" titla="false" ajax="true"]