Maximum Points You Can Obtain from Cards - Practice Coding Problems

Maximum Points You Can Obtain from Cards - Problem

Imagine you're playing a strategic card game where you have a row of cards laid out in front of you, each with a specific point value. The twist? You can only pick cards from the very beginning or the very end of the row - no cherry-picking from the middle!

You're given an array cardPoints representing the points on each card, and you must take exactly k cards to maximize your score. Your goal is to determine the maximum possible sum of points you can achieve.

Example: If you have cards [1,2,3,4,5,6,1] and need to pick k=3 cards, you could take the first 3 cards (1+2+3=6), the last 3 cards (6+1+1=8), or a mix like first 1 and last 2 cards (1+1+1=3). The optimal strategy gives you 8 points!

Input: An integer array cardPoints and an integer k
Output: The maximum score (sum) you can obtain by picking exactly k cards from either end

Input & Output

example_1.py — Basic Case

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

› Output: 12

💡 Note: Take the last 3 cards: 5 + 6 + 1 = 12. This gives the maximum possible score.

example_2.py — Mixed Selection

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

› Output: 4

💡 Note: Take any 2 cards since they all have the same value: 2 + 2 = 4.

example_3.py — All Cards

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

› Output: 55

💡 Note: We must take all cards since k equals the array length: 9+7+7+9+7+7+9 = 55.

Constraints

1 ≤ cardPoints.length ≤ 10⁵
1 ≤ cardPoints[i] ≤ 10⁴
1 ≤ k ≤ cardPoints.length
You must take exactly k cards
Cards can only be taken from the beginning or end of the array

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Layout all cards in a row. You can only pick from the leftmost or rightmost positions.

Sliding Window

Start with k cards from left, then slide the selection window toward the right.

Efficient Updates

Instead of recalculating sums, just subtract the card being removed and add the new card.

Track Maximum

Keep track of the highest sum encountered during the sliding process.

Key Takeaway

🎯 Key Insight: Instead of trying all combinations separately, we can efficiently slide between taking all cards from one end to all cards from the other end, updating our running sum in O(1) time for each step!

Asked in

f Meta 42 a Amazon 38 ⊞ Microsoft 29 G Google 24

The optimal solution uses a sliding window technique with O(k) time complexity. Start by taking k cards from the left, then efficiently slide the window to replace left cards with right cards one by one, tracking the maximum sum. This avoids the O(k²) redundant calculations of the brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(k²)	O(1)	Try every possible way to pick k cards from both ends
Sliding Window (Optimal)	O(k)	O(1)	Use prefix sums and sliding window technique to avoid recalculation

Brute Force (Try All Combinations) — Algorithm Steps

For each possible split i from 0 to k
Take i cards from the beginning of the array
Take (k-i) cards from the end of the array
Calculate the sum of these cards
Keep track of the maximum sum seen so far

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with taking 0 cards from left, k cards from right

Calculate Sum

Sum the selected cards and compare with current maximum

Shift Selection

Take 1 more from left, 1 less from right, repeat

Continue

Keep shifting until we take k cards from left, 0 from right

Code -

solution.c — C

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

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

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

Time & Space Complexity

Time Complexity

⏱️

O(k²)

We try k+1 different combinations, and for each combination we sum up to k elements

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track the current and maximum sum

✓ Linear Space

76.4K Views

High Frequency

~18 min Avg. Time

1.8K 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