# Solving Leetcode Interviews in Seconds with AI: Maximum Points You Can Obtain from Cards


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1423" 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 several cards arranged in a row, and each card has an associated number of points. The points are given in the integer array cardPoints. In one step, you can take one card from the beginning or from the end of the row. You have to take exactly k cards. Your score is the sum of the points of the cards you have taken. Given the integer array cardPoints and the integer k, return the maximum score you can obtain.   Example 1:  Input: cardPoints = [1,2,3,4,5,6,1], k = 3 Output: 12 Explanation: After the first step, your score will always be 1. However, choosing the rightmost card first will maximize your total score. The optimal strategy is to take the three cards on the right, giving a final score of 1 + 6 + 5 = 12.  Example 2:  Input: cardPoints = [2,2,2], k = 2 Output: 4 Explanation: Regardless of which two cards you take, your score will always be 4.  Example 3:  Input: cardPoints = [9,7,7,9,7,7,9], k = 7 Output: 55 Explanation: You have to take all the cards. Your score is the sum of points of all cards.    Constraints:  1 <= cardPoints.length <= 105 1 <= cardPoints[i] <= 104 1 <= k <= cardPoints.length  

	# Explanation
	Here's a breakdown of the approach, followed by the Python code:

*   **Key Idea:** Instead of directly finding the maximum score, find the *minimum* sum of the subarray of length `n-k`. The maximum score is then the total sum of `cardPoints` minus this minimum subarray sum. This avoids redundant calculations.
*   **Sliding Window:** Use a sliding window of size `n-k` to efficiently compute the minimum subarray sum.
*   **Optimization:** Precompute the total sum of the array to make the final calculation efficient.

*   **Runtime Complexity:** O(n), where n is the length of `cardPoints`.
*   **Storage Complexity:** O(1).

	
	# Code
	```python
	def maxScore(cardPoints, k):
    """
    Calculates the maximum score obtainable by taking k cards from the beginning or end of the row.

    Args:
        cardPoints (list): A list of integers representing the points on each card.
        k (int): The number of cards to take.

    Returns:
        int: The maximum score obtainable.
    """

    n = len(cardPoints)
    window_size = n - k
    total_sum = sum(cardPoints)

    if window_size == 0:
        return total_sum

    min_subarray_sum = float('inf')
    current_subarray_sum = 0

    for i in range(n):
        current_subarray_sum += cardPoints[i]

        if i >= window_size:
            current_subarray_sum -= cardPoints[i - window_size]

        if i >= window_size - 1:
            min_subarray_sum = min(min_subarray_sum, current_subarray_sum)

    return total_sum - min_subarray_sum
	```