Minimize the Maximum of Two Arrays - Practice Coding Problems

Minimize the Maximum of Two Arrays - Problem

Imagine you're a data architect tasked with constructing two special arrays with very specific requirements. You need to build arr1 and arr2 from scratch, starting with empty arrays, by carefully selecting positive integers.

Your mission: Fill these arrays while satisfying all these constraints:

arr1 must contain exactly uniqueCnt1 distinct positive integers, where none are divisible by divisor1
arr2 must contain exactly uniqueCnt2 distinct positive integers, where none are divisible by divisor2
No number can appear in both arrays - they must be completely disjoint

Your goal is to minimize the largest number that appears in either array. Think of it as trying to keep both arrays as "small" as possible while meeting all requirements.

Example: If divisor1=2, divisor2=3, uniqueCnt1=1, uniqueCnt2=1, you could put 1 in arr1 (not divisible by 2) and 2 in arr2 (not divisible by 3). The maximum would be 2.

Input & Output

example_1.py — Basic Case

$ Input: divisor1 = 2, divisor2 = 3, uniqueCnt1 = 1, uniqueCnt2 = 1

› Output: 2

💡 Note: We need 1 number for arr1 (not divisible by 2) and 1 number for arr2 (not divisible by 3). We can use arr1 = [1] and arr2 = [2]. The maximum is 2.

example_2.py — Larger Counts

$ Input: divisor1 = 3, divisor2 = 5, uniqueCnt1 = 2, uniqueCnt2 = 1

› Output: 3

💡 Note: We need 2 numbers for arr1 (not divisible by 3) and 1 for arr2 (not divisible by 5). We can use arr1 = [1, 2] and arr2 = [3]. Maximum is 3.

example_3.py — Edge Case with Same Divisors

$ Input: divisor1 = 2, divisor2 = 2, uniqueCnt1 = 1, uniqueCnt2 = 1

› Output: 3

💡 Note: Both arrays need numbers not divisible by 2. We can use arr1 = [1] and arr2 = [3] since no number can be in both arrays. Maximum is 3.

Constraints

2 ≤ divisor1, divisor2 ≤ 10⁵
1 ≤ uniqueCnt1, uniqueCnt2 ≤ 10⁹
No integer appears in both arrays
All numbers must be positive integers

Visualization

Tap to expand

Understanding the Visualization

Categorize Numbers

Group numbers by what arrays they can join based on divisibility

Count Available Numbers

Use inclusion-exclusion to count valid numbers up to any maximum

Binary Search Range

Search for minimum maximum that allows valid distribution

Greedy Allocation

Use flexible numbers first, then array-specific numbers

Key Takeaway

🎯 Key Insight: Binary search on the answer combined with mathematical counting makes this problem tractable even for large inputs

Asked in

G Google 25 f Meta 18 a Amazon 15 ⊞ Microsoft 12

This problem is optimally solved using binary search on the answer combined with inclusion-exclusion principle from number theory. The key insight is that if maximum M works, then M+1, M+2, etc. also work, making the problem monotonic and suitable for binary search. We use mathematical counting to determine how many valid numbers exist up to any maximum in O(1) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(n)	O(1)	Try every possible maximum value starting from 1 until we find one that works
Binary Search (Optimal)	O(log(uniqueCnt1 + uniqueCnt2))	O(1)	Use binary search to find the minimum maximum value efficiently

Brute Force (Linear Search) — Algorithm Steps

Start with candidate maximum = max(uniqueCnt1, uniqueCnt2)
For current maximum, count valid numbers for arr1 (not divisible by divisor1)
Count valid numbers for arr2 (not divisible by divisor2)
Count numbers that could go in either array (not divisible by either divisor)
Check if we can distribute uniqueCnt1 + uniqueCnt2 numbers total
If not possible, increment maximum and repeat

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Testing

Begin with maximum = max(uniqueCnt1, uniqueCnt2)

Count Valid Numbers

For current max, count how many numbers work for each array

Check Feasibility

See if we can fit all required numbers

Increment if Needed

If not feasible, try next higher maximum

Code -

solution.c — C

#include <stdio.h>

long long gcd(long long a, long long b) {
    while (b) {
        long long temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

long long lcm(long long a, long long b) {
    return a * b / gcd(a, b);
}

long long max_ll(long long a, long long b) {
    return a > b ? a : b;
}

int canAchieve(long long maxVal, int divisor1, int divisor2, int uniqueCnt1, int uniqueCnt2) {
    long long valid1 = maxVal - maxVal / divisor1;
    long long valid2 = maxVal - maxVal / divisor2;
    long long lcmVal = lcm(divisor1, divisor2);
    long long bothValid = maxVal - maxVal / divisor1 - maxVal / divisor2 + maxVal / lcmVal;
    
    long long need1 = max_ll(0, uniqueCnt1 - bothValid);
    long long need2 = max_ll(0, uniqueCnt2 - bothValid);
    
    return need1 <= valid1 - bothValid && need2 <= valid2 - bothValid &&
           uniqueCnt1 + uniqueCnt2 <= valid1 + valid2 - bothValid;
}

int minimizeSet(int divisor1, int divisor2, int uniqueCnt1, int uniqueCnt2) {
    long long maxVal = max_ll(uniqueCnt1, uniqueCnt2);
    
    while (!canAchieve(maxVal, divisor1, divisor2, uniqueCnt1, uniqueCnt2)) {
        maxVal++;
    }
    
    return maxVal;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

In worst case, we might check every number up to the answer, and the answer can be large

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counting

✓ Linear Space

27.4K Views

Medium Frequency

~25 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler