# Solving Leetcode Interviews in Seconds with AI: Maximize the Minimum Game Score


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3449" 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
	> You are given an array points of size n and an integer m. There is another array gameScore of size n, where gameScore[i] represents the score achieved at the ith game. Initially, gameScore[i] == 0 for all i. You start at index -1, which is outside the array (before the first position at index 0). You can make at most m moves. In each move, you can either:  Increase the index by 1 and add points[i] to gameScore[i]. Decrease the index by 1 and add points[i] to gameScore[i].  Note that the index must always remain within the bounds of the array after the first move. Return the maximum possible minimum value in gameScore after at most m moves.   Example 1:  Input: points = [2,4], m = 3 Output: 4 Explanation: Initially, index i = -1 and gameScore = [0, 0].    Move Index gameScore     Increase i 0 [2, 0]   Increase i 1 [2, 4]   Decrease i 0 [4, 4]    The minimum value in gameScore is 4, and this is the maximum possible minimum among all configurations. Hence, 4 is the output.  Example 2:  Input: points = [1,2,3], m = 5 Output: 2 Explanation: Initially, index i = -1 and gameScore = [0, 0, 0].    Move Index gameScore     Increase i 0 [1, 0, 0]   Increase i 1 [1, 2, 0]   Decrease i 0 [2, 2, 0]   Increase i 1 [2, 4, 0]   Increase i 2 [2, 4, 3]    The minimum value in gameScore is 2, and this is the maximum possible minimum among all configurations. Hence, 2 is the output.    Constraints:  2 <= n == points.length <= 5 * 104 1 <= points[i] <= 106 1 <= m <= 109  

	# Explanation
	Here's the solution to the problem, with explanations and code:

*   **Binary Search:** Perform a binary search on the possible values of the minimum score. The search space will be from 0 to the maximum possible score achievable.
*   **Check Feasibility:** For each mid-value in the binary search, check if it's possible to achieve a minimum score of at least 'mid' for all elements in `gameScore` using at most 'm' moves.
*   **Greedy Assignment:** The feasibility check is done using a greedy approach. For each element in `gameScore`, determine the minimum number of moves required to bring its score up to the current 'mid' value. Sum up all these moves. If the total moves needed is less than or equal to 'm', then the 'mid' value is feasible.

*   **Runtime Complexity:** O(n log(m * max(points)))
*   **Storage Complexity:** O(1)

	
	# Code
	```python
	def solve():
    n, m = map(int, input().split())
    points = list(map(int, input().split()))
    
    def is_possible(mid):
        moves_needed = 0
        for point in points:
            if point >= mid:
                continue
            needed = mid - point
            moves_needed += needed
            if moves_needed > m:
                return False
        return moves_needed <= m

    low = 0
    high = m * max(points)  # Adjust based on input constraints
    ans = 0

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

    print(ans)

# Read input and call solve function
# input_str = """2 3
# 2 4"""
# from io import StringIO
# import sys
# sys.stdin = StringIO(input_str)

# solve()

def max_possible_min_score(points, m):
    n = len(points)

    def is_possible(mid):
        moves_needed = 0
        for point in points:
            if point >= mid:
                continue
            needed_moves = mid - point
            moves_needed += needed_moves
            if moves_needed > m:
                return False
        return moves_needed <= m

    low = 0
    high = max(points) + m 
    ans = 0

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

    return ans
	```