Maximum Points You Can Obtain from Cards

Maximum Points You Can Obtain from Cards - Problem

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.

Input & Output

Example 1 — Basic Case

$ Input: cardPoints = [1,2,3,4,5,6,1], k = 3

› Output: 12

💡 Note: Take 3 cards from right end: [5,6,1] gives sum = 12. This is better than other combinations like taking 1 from left [1] and 2 from right [6,1] which gives 1+6+1=8.

Example 2 — Mixed Selection

$ Input: cardPoints = [2,2,2], k = 2

› Output: 4

💡 Note: Can take 2 cards from left [2,2] = 4, or 2 cards from right [2,2] = 4, or 1 from each end [2,2] = 4. All give the same result.

Example 3 — All Cards

$ Input: cardPoints = [9,7,7,9,7,7,9], k = 7

› Output: 55

💡 Note: Take all cards since k equals array length: 9+7+7+9+7+7+9 = 55

Constraints

1 ≤ cardPoints.length ≤ 10⁵
1 ≤ cardPoints[i] ≤ 10⁴
1 ≤ k ≤ cardPoints.length

Visualization

Tap to expand

Asked in

A Amazon 15 M Microsoft 12 G Google 8 F Facebook 6

The key insight is that maximizing k cards from edges equals minimizing n-k cards from the middle. Best approach uses sliding window to find minimum sum of middle cards in O(n) time. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(k²) Space: O(1)

For each possible split (0 to k cards from left, remaining from right), calculate the sum and track the maximum. This explores all valid combinations of picking cards from both ends.

Prefix Sum Optimization

⏱️ Time: O(k²) Space: O(n)

Calculate prefix sums for efficient left sum computation, then try each split of i cards from left and k-i cards from right. This reduces repeated summation work.

Sliding Window (Optimal)

⏱️ Time: O(n) Space: O(1)

Key insight: Maximum sum of k cards from edges equals total sum minus minimum sum of n-k middle cards. Use sliding window to find minimum sum of the middle segment efficiently.

Brute Force - Try All Combinations — Algorithm Steps

Step 1: For each i from 0 to k, take i cards from left and k-i cards from right
Step 2: Calculate sum for each combination and track maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Split i=0

0 cards from left, k cards from right

Try Split i=1

1 card from left, k-1 cards from right

Continue

Try all splits and find maximum sum

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int solution(int* cardPoints, int n, int k) {
    int maxSum = 0;
    
    // Try all combinations: i cards from left, k-i cards from right
    for (int i = 0; i <= k; i++) {
        int leftSum = 0;
        for (int j = 0; j < i; j++) {
            leftSum += cardPoints[j];
        }
        
        int rightSum = 0;
        if (k - i > 0) {
            for (int j = n - (k - i); j < n; j++) {
                rightSum += cardPoints[j];
            }
        }
        
        if (leftSum + rightSum > maxSum) {
            maxSum = leftSum + rightSum;
        }
    }
    
    return maxSum;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int cardPoints[100];
    int n = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL && strlen(token) > 0) {
        cardPoints[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", solution(cardPoints, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k²)

For each of k splits, we sum up to k elements

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track current and maximum sum

✓ Linear Space

89.0K Views

Medium Frequency

~15 min Avg. Time

2.5K 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 - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler