Maximum Coins From K Consecutive Bags - Practice Coding Problems

Maximum Coins From K Consecutive Bags - Problem

Array Binary Search Greedy Sliding Window Sorting Prefix Sum Medium

Imagine an infinite treasure hunt along a number line! There are bags at every integer coordinate, and some of these bags contain precious coins. You're given a 2D array coins where each element coins[i] = [l_i, r_i, c_i] tells you that every bag from position l_i to r_i (inclusive) contains exactly c_i coins.

Here's the catch: the coin segments don't overlap, so you have a clear map of where all the treasures are located. Your mission is to find the maximum number of coins you can collect by choosing any k consecutive bags along the number line.

Goal: Return the maximum coins you can obtain from k consecutive bags.
Input: A 2D array of coin segments and an integer k
Output: Maximum coins from k consecutive positions

Input & Output

example_1.py — Basic Case

$ Input: coins = [[2,4,3],[5,6,1],[7,9,2]], k = 4

› Output: 8

💡 Note: The optimal window is positions [4,5,6,7] which gives us 3+1+2+2 = 8 coins. Position 4 has 3 coins, position 5 has 1 coin, position 6 has 0 coins (gap), and positions 7 has 2 coins.

example_2.py — Overlapping Window

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

› Output: 6

💡 Note: The best window is positions [4,5,6] giving us 3+3+3 = 9 coins, or positions [2,3,4] giving us 2+2+3 = 7 coins. Wait, let me recalculate: [4,5,6] = 3+3+3 = 9.

example_3.py — Large Gap

$ Input: coins = [[1,2,5],[100,101,3]], k = 3

› Output: 10

💡 Note: Best window is [1,2,3] with 5+5+0 = 10 coins, or [100,101,102] with 3+3+0 = 6 coins. The first option is better.

Constraints

1 ≤ k ≤ 2 × 10⁴
0 ≤ coins.length ≤ 10³
coins[i].length == 3
1 ≤ l_i ≤ r_i ≤ 2 × 10⁴
1 ≤ c_i ≤ 1000
The segments in coins are non-overlapping

Visualization

Tap to expand

Understanding the Visualization

🗺️ Map the Treasure Zones

Identify all the segments where treasures exist and note their boundaries

📍 Mark Critical Points

Focus only on positions where treasure density changes (segment boundaries)

🏃 Sliding Window Search

Move a collection window of size k across all possible positions

💰 Track Maximum Haul

Keep track of the window position that yields the most treasure

Key Takeaway

🎯 Key Insight: Instead of checking every possible position on the infinite line, we only need to examine the critical points where coin densities change (segment boundaries). This reduces an infinite search space to just a few important positions, making the solution efficient and scalable.

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses coordinate compression to reduce the infinite number line to critical boundary points, then applies a sliding window technique with prefix sums. This achieves O(n log n) time complexity by avoiding redundant position checks and focusing only on positions where coin values change.

Common Approaches

Approach	Time	Space	Notes
✓ Coordinate Compression + Sliding Window	O(n log n + m)	O(m)	Compress coordinates to critical points and use sliding window with prefix sums
Brute Force (Check All Windows)	O(R × k × n)	O(1)	Try every possible starting position and calculate coins for k consecutive bags

Coordinate Compression + Sliding Window — Algorithm Steps

Extract all critical coordinates (segment boundaries) and sort them
Build a coordinate mapping and coin value array for compressed coordinates
Calculate prefix sums for efficient range sum queries
Use sliding window to find the maximum sum of k consecutive compressed positions
Handle cases where k spans beyond available coordinates

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Critical Points

Find all segment boundaries where coin values change

Compress Coordinates

Map the infinite line to only meaningful positions

Build Prefix Sums

Create cumulative sum array for fast range queries

Sliding Window

Efficiently find maximum sum of k consecutive positions

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int maximumCoins(int** coins, int coinsSize, int* coinsColSize, int k) {
    if (coinsSize == 0) return 0;
    
    // Find coordinate bounds
    int minCoord = INT_MAX;
    int maxCoord = INT_MIN;
    for (int i = 0; i < coinsSize; i++) {
        if (coins[i][0] < minCoord) minCoord = coins[i][0];
        if (coins[i][1] > maxCoord) maxCoord = coins[i][1];
    }
    
    // Handle large k case
    if (k > maxCoord - minCoord + 1) {
        long long total = 0;
        for (int i = 0; i < coinsSize; i++) {
            total += (long long)coins[i][2] * (coins[i][1] - coins[i][0] + 1);
        }
        return (int)total;
    }
    
    int maxCoins = 0;
    
    // Sliding window approach
    for (int start = minCoord; start <= maxCoord - k + 1; start++) {
        int currentCoins = 0;
        for (int pos = start; pos < start + k; pos++) {
            for (int i = 0; i < coinsSize; i++) {
                if (coins[i][0] <= pos && pos <= coins[i][1]) {
                    currentCoins += coins[i][2];
                    break;
                }
            }
        }
        if (currentCoins > maxCoins) {
            maxCoins = currentCoins;
        }
    }
    
    return maxCoins;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n + m)

n log n for sorting coordinates, m for sliding window where m is number of critical points

⚡ Linearithmic

Space Complexity

O(m)

Space for compressed coordinates, coin values, and prefix sums

✓ Linear Space

23.8K Views

Medium-High Frequency

~18 min Avg. Time

892 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

Coordinate Compression + Sliding Window — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler