# Solving Leetcode Interviews in Seconds with AI: Minimize the Maximum of Two Arrays


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2513" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> We have two arrays arr1 and arr2 which are initially empty. You need to add positive integers to them such that they satisfy all the following conditions:  arr1 contains uniqueCnt1 distinct positive integers, each of which is not divisible by divisor1. arr2 contains uniqueCnt2 distinct positive integers, each of which is not divisible by divisor2. No integer is present in both arr1 and arr2.  Given divisor1, divisor2, uniqueCnt1, and uniqueCnt2, return the minimum possible maximum integer that can be present in either array.   Example 1:  Input: divisor1 = 2, divisor2 = 7, uniqueCnt1 = 1, uniqueCnt2 = 3 Output: 4 Explanation:  We can distribute the first 4 natural numbers into arr1 and arr2. arr1 = [1] and arr2 = [2,3,4]. We can see that both arrays satisfy all the conditions. Since the maximum value is 4, we return it.  Example 2:  Input: divisor1 = 3, divisor2 = 5, uniqueCnt1 = 2, uniqueCnt2 = 1 Output: 3 Explanation:  Here arr1 = [1,2], and arr2 = [3] satisfy all conditions. Since the maximum value is 3, we return it. Example 3:  Input: divisor1 = 2, divisor2 = 4, uniqueCnt1 = 8, uniqueCnt2 = 2 Output: 15 Explanation:  Here, the final possible arrays can be arr1 = [1,3,5,7,9,11,13,15], and arr2 = [2,6]. It can be shown that it is not possible to obtain a lower maximum satisfying all conditions.     Constraints:  2 <= divisor1, divisor2 <= 105 1 <= uniqueCnt1, uniqueCnt2 < 109 2 <= uniqueCnt1 + uniqueCnt2 <= 109  

	# Explanation
	Here's the breakdown of the solution:

*   **Binary Search:** Use binary search to find the minimum possible maximum integer. The search space is between 1 and a sufficiently large number (e.g., 10^10).
*   **Check Function:** Implement a helper function `check(mid)` that determines if it's possible to populate `arr1` and `arr2` such that the maximum element is `mid`.  This involves calculating how many numbers are not divisible by `divisor1`, `divisor2`, and `lcm(divisor1, divisor2)` within the range `[1, mid]`.
*   **LCM Calculation:** Efficiently calculate the least common multiple (LCM) of `divisor1` and `divisor2`.

*   **Runtime Complexity:** O(log(N)), where N is the search space (e.g., 10^10).  **Storage Complexity:** O(1).

	
	# Code
	```python
	import math

def solve():
    divisor1, divisor2, uniqueCnt1, uniqueCnt2 = map(int, input().split())

    def gcd(a, b):
        while b:
            a, b = b, a % b
        return a

    def lcm(a, b):
        return (a * b) // gcd(a, b)

    def check(mid):
        count1 = mid - mid // divisor1
        count2 = mid - mid // divisor2
        count_both = mid - mid // divisor1 - mid // divisor2 + mid // lcm_val

        return count1 >= uniqueCnt1 and count2 >= uniqueCnt2 and count_both >= uniqueCnt1 + uniqueCnt2
    
    lcm_val = lcm(divisor1, divisor2)
    
    low = 1
    high = 10**10  # Set a sufficiently large upper bound
    ans = high

    while low <= high:
        mid = (low + high) // 2
        if check(mid):
            ans = mid
            high = mid - 1
        else:
            low = mid + 1

    print(ans)

# solve()

def minimize_maximum(divisor1: int, divisor2: int, uniqueCnt1: int, uniqueCnt2: int) -> int:
    """
    Given divisor1, divisor2, uniqueCnt1, and uniqueCnt2, return the minimum possible maximum integer
    that can be present in either array.
    """

    def gcd(a, b):
        while b:
            a, b = b, a % b
        return a

    def lcm(a, b):
        return (a * b) // gcd(a, b)

    def check(mid):
        count1 = mid - mid // divisor1
        count2 = mid - mid // divisor2
        count_both = mid - mid // divisor1 - mid // divisor2 + mid // lcm_val

        return count1 >= uniqueCnt1 and count2 >= uniqueCnt2 and count_both >= uniqueCnt1 + uniqueCnt2
    
    lcm_val = lcm(divisor1, divisor2)
    
    low = 1
    high = 10**10  # Set a sufficiently large upper bound
    ans = high

    while low <= high:
        mid = (low + high) // 2
        if check(mid):
            ans = mid
            high = mid - 1
        else:
            low = mid + 1

    return ans
	```