Maximum Points From Cards

Prefix/suffix splits

Any legal result takes some number i from the front and the remaining k - i from the back. Build cumulative totals for both ends, then score every i from 0 through k.

def max_points_cards(card_points: list[int], k: int) -> int:
    front = [0] * (k + 1)
    back = [0] * (k + 1)
 
    for count in range(1, k + 1):
        front[count] = front[count - 1] + card_points[count - 1]
        back[count] = back[count - 1] + card_points[-count]
 
    best = 0
    for take_front in range(k + 1):
        take_back = k - take_front
        best = max(best, front[take_front] + back[take_back])
 
    return best

The loop includes both extremes: take everything from the back when take_front == 0, and everything from the front when take_front == k.

Time O(k) — build two length-k totals and test k + 1 splits. Space O(k) for the prefix and suffix totals.

Minimum interior window

Reverse your point of view. Taking k cards from the two ends leaves exactly n - k neighboring cards in the middle. Since taken score = total score - leftover score, maximizing what you take is the same as minimizing that fixed-size leftover window.

def max_points_cards(card_points: list[int], k: int) -> int:
    total = 0
    for points in card_points:
        total += points
 
    interior_size = len(card_points) - k
    if interior_size == 0:
        return total
 
    interior_sum = 0
    for i in range(interior_size):
        interior_sum += card_points[i]
 
    min_interior = interior_sum
    for right in range(interior_size, len(card_points)):
        interior_sum += card_points[right]
        interior_sum -= card_points[right - interior_size]
        min_interior = min(min_interior, interior_sum)
 
    return total - min_interior

Every legal front/back choice corresponds to one interior window, including an empty one when k == n. Checking every interior window therefore checks every possible score.

Time O(n) — total the row and slide across it once. Space O(1) — only the total, current interior sum, and minimum are stored.

The split method can touch fewer cards when k is small; the interior method earns its place here because it exposes the fixed-window transformation without allocating arrays.