Maximum Coins Heroes Can Collect - Practice Coding Problems

Maximum Coins Heroes Can Collect - Problem

Array Two Pointers Binary Search Sorting Prefix Sum Medium

⚔️ Maximum Coins Heroes Can Collect

Imagine an epic battle where n brave heroes face off against m fearsome monsters to collect precious coins! Each hero has a specific power level, and each monster guards a treasure of coins.

The Rules:

A hero can defeat a monster only if the hero's power is greater than or equal to the monster's power
Each hero can defeat multiple monsters, but can only defeat each monster once
Heroes don't lose health after battles - they can keep fighting!
Multiple heroes can defeat the same monster (but each hero gets coins only once per monster)

Your Goal: For each hero, calculate the maximum coins they can collect by strategically choosing which monsters to defeat.

Input:

heroes[i] - power of the i-th hero
monsters[j] - power of the j-th monster
coins[j] - coins earned for defeating the j-th monster

Output: An array where result[i] is the maximum coins the i-th hero can collect.

Input & Output

example_1.py — Basic Test Case

$ Input: heroes = [1, 4, 2], monsters = [1, 2, 3], coins = [1, 2, 3]

› Output: [1, 6, 3]

💡 Note: Hero 1 (power=1) can defeat monster 1 (power=1) → 1 coin. Hero 2 (power=4) can defeat all monsters (1,2,3) → 1+2+3 = 6 coins. Hero 3 (power=2) can defeat monsters 1,2 → 1+2 = 3 coins.

example_2.py — Heroes with Same Power

$ Input: heroes = [5, 5], monsters = [2, 3, 7], coins = [1, 2, 4]

› Output: [3, 3]

💡 Note: Both heroes have power 5, so both can defeat monsters with power 2 and 3, earning 1+2 = 3 coins each. Neither can defeat the monster with power 7.

example_3.py — Edge Case - Weak Heroes

$ Input: heroes = [1, 1], monsters = [5, 10], coins = [10, 20]

› Output: [0, 0]

💡 Note: Both heroes have power 1, but all monsters have higher power (5, 10), so no hero can defeat any monster. Each hero collects 0 coins.

Constraints

1 ≤ n, m ≤ 10⁵
1 ≤ heroes[i], monsters[i], coins[i] ≤ 10⁵
All arrays are 0-indexed in implementation

Visualization

Tap to expand

Understanding the Visualization

Assess the Battlefield

Heroes survey all monsters and their rewards

Sort by Difficulty

Arrange monsters from weakest to strongest for strategic planning

Calculate Cumulative Rewards

Build a prefix sum to know total coins up to any point

Find Each Hero's Limit

Use binary search to find the strongest monster each hero can defeat

Collect Maximum Coins

Each hero collects coins from all defeatable monsters

Key Takeaway

🎯 Key Insight: By sorting monsters and using binary search with prefix sums, we transform an O(n×m) brute force solution into an efficient O((n+m) log m) algorithm that scales beautifully!

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 31

The optimal solution uses sorting + binary search + prefix sum. First, sort monsters by power and create a prefix sum array of coins. For each hero, use binary search to find the rightmost monster they can defeat, then use the prefix sum to get the total coins in O(1) time. This achieves O((n + m) log m) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Monster)	O(n*m)	O(1)	For each hero, check every monster and sum up coins from defeatable ones
Sorting + Binary Search + Prefix Sum	O((n + m) log m)	O(m)	Sort monsters by power, create prefix sum array, then binary search for each hero

Brute Force (Check Every Monster) — Algorithm Steps

For each hero in the heroes array
Initialize coins_collected = 0 for current hero
For each monster in the monsters array
If hero_power >= monster_power, add coins[monster_index] to coins_collected
Store coins_collected in result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Hero

Pick the first hero with power level

Check All Monsters

Compare hero power with each monster power

Collect Coins

Sum coins from all defeatable monsters

Repeat

Move to next hero and repeat the process

Code -

solution.c — C

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

int* maximumCoins(int* heroes, int heroesSize, int* monsters, int monstersSize, int* coins) {
    int* result = (int*)malloc(heroesSize * sizeof(int));
    
    for (int i = 0; i < heroesSize; i++) {
        int heroPower = heroes[i];
        int totalCoins = 0;
        
        for (int j = 0; j < monstersSize; j++) {
            if (heroPower >= monsters[j]) {
                totalCoins += coins[j];
            }
        }
        
        result[i] = totalCoins;
    }
    
    return result;
}

int main() {
    int heroes[1000], monsters[1000], coins[1000];
    int heroesSize = 0, monstersSize = 0;
    char c;
    
    // Parse heroes
    while (scanf("%d%c", &heroes[heroesSize], &c) == 2) {
        heroesSize++;
        if (c == '\n') break;
    }
    
    // Parse monsters
    while (scanf("%d%c", &monsters[monstersSize], &c) == 2) {
        monstersSize++;
        if (c == '\n') break;
    }
    
    // Parse coins
    for (int i = 0; i < monstersSize; i++) {
        scanf("%d", &coins[i]);
    }
    
    int* result = maximumCoins(heroes, heroesSize, monsters, monstersSize, coins);
    
    for (int i = 0; i < heroesSize; i++) {
        printf("%d", result[i]);
        if (i < heroesSize - 1) printf(" ");
    }
    printf("\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m)

For each of n heroes, we check all m monsters

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for tracking, result array doesn't count as extra space

✓ Linear Space

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

⚔️ Maximum Coins Heroes Can Collect

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check Every Monster) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler