# Solving Leetcode Interviews in Seconds with AI: Maximize Win From Two Segments


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2555" 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
	> There are some prizes on the X-axis. You are given an integer array prizePositions that is sorted in non-decreasing order, where prizePositions[i] is the position of the ith prize. There could be different prizes at the same position on the line. You are also given an integer k. You are allowed to select two segments with integer endpoints. The length of each segment must be k. You will collect all prizes whose position falls within at least one of the two selected segments (including the endpoints of the segments). The two selected segments may intersect.  For example if k = 2, you can choose segments [1, 3] and [2, 4], and you will win any prize i that satisfies 1 <= prizePositions[i] <= 3 or 2 <= prizePositions[i] <= 4.  Return the maximum number of prizes you can win if you choose the two segments optimally.   Example 1:  Input: prizePositions = [1,1,2,2,3,3,5], k = 2 Output: 7 Explanation: In this example, you can win all 7 prizes by selecting two segments [1, 3] and [3, 5].  Example 2:  Input: prizePositions = [1,2,3,4], k = 0 Output: 2 Explanation: For this example, one choice for the segments is [3, 3] and [4, 4], and you will be able to get 2 prizes.     Constraints:  1 <= prizePositions.length <= 105 1 <= prizePositions[i] <= 109 0 <= k <= 109  prizePositions is sorted in non-decreasing order.     

	# Explanation
	Here's a breakdown of the approach, complexity, and code:

*   **High-Level Approach:**
    *   Calculate the maximum number of prizes obtainable from a single segment ending at each prize position. This can be done efficiently using binary search or two pointers.
    *   Iterate through all possible split points in the sorted prize positions. For each split, consider the best single segment ending before the split point and the best single segment starting after the split point.
    *   The maximum number of prizes is the maximum sum of prizes from the two segments across all splits.

*   **Complexity:**
    *   Runtime Complexity: O(n log n) due to binary search for finding segment ranges.  O(n) if using two pointers.
    *   Storage Complexity: O(n) to store the prefix sums of prizes covered by a single segment ending at index i.

	
	# Code
	```python
	def max_prizes(prizePositions, k):
    n = len(prizePositions)
    max_prizes_ending_at = [0] * n
    prefix_sums = [0] * (n + 1)

    for i in range(n):
        prefix_sums[i + 1] = prefix_sums[i] + 1

    def count_prizes_in_segment(start, end):
        left = 0
        right = n - 1
        start_index = -1

        while left <= right:
            mid = (left + right) // 2
            if prizePositions[mid] >= start:
                start_index = mid
                right = mid - 1
            else:
                left = mid + 1

        if start_index == -1:
            return 0

        left = 0
        right = n - 1
        end_index = -1

        while left <= right:
            mid = (left + right) // 2
            if prizePositions[mid] <= end:
                end_index = mid
                left = mid + 1
            else:
                right = mid - 1
        if end_index == -1:
            return 0
        
        return end_index - start_index + 1


    for i in range(n):
        max_prizes_ending_at[i] = count_prizes_in_segment(prizePositions[i] - k, prizePositions[i])

    max_so_far = [0] * n
    max_so_far[0] = max_prizes_ending_at[0]
    for i in range(1, n):
        max_so_far[i] = max(max_so_far[i - 1], max_prizes_ending_at[i])

    ans = 0
    for i in range(n - 1):
        first_segment_max = max_so_far[i]
        
        second_segment_max = 0
        for j in range(i + 1, n):
            second_segment_max = max(second_segment_max, count_prizes_in_segment(prizePositions[j] , prizePositions[j] + k))
        
        ans = max(ans, first_segment_max + second_segment_max)

    return ans
	```