Maximum Points After Enemy Battles - Practice Coding Problems

Maximum Points After Enemy Battles - Problem

Array Greedy Medium

Maximum Points After Enemy Battles

You are a warrior facing multiple enemies in battle! Each enemy has a certain energy value that represents how much energy it takes to defeat them.

You start with some currentEnergy and 0 points. All enemies are initially unmarked (alive).

You can perform two types of operations:

🗡️ Attack Operation: Choose an unmarked enemy with energy ≤ your current energy
• Gain 1 point
• Lose energy equal to the enemy's energy value

🔋 Absorb Operation: If you have at least 1 point, choose any unmarked enemy
• Gain energy equal to the enemy's energy value
• Mark the enemy (it's absorbed and can't be used again)

Your goal is to find the maximum points you can earn by optimally combining these operations!

Example: With enemies [3,2,2] and currentEnergy=2
• You can't attack the first enemy (need 3 energy, have 2)
• Attack second enemy: gain 1 point, energy becomes 0
• Since you have 1 point, absorb first enemy: gain 3 energy (total 3)
• Attack third enemy: gain 1 point, energy becomes 1
• Result: 2 points maximum

Input & Output

example_1.py — Basic Strategy

$ Input: enemyEnergies = [3,2,2], currentEnergy = 2

› Output: 3

💡 Note: Attack second enemy (energy 2): gain 1 point, energy becomes 0. Since we have 1 point, absorb first enemy (energy 3): energy becomes 3. Now attack third enemy: gain 1 point, energy becomes 1. Absorb the already defeated second enemy isn't possible, so attack third enemy again: not possible. Wait, we can absorb the third enemy for energy 2, then attack the already defeated enemies. Actually, optimal is: attack enemy with energy 2, absorb all others, then attack repeatedly. Total energy after absorbing = 0 + 3 + 2 = 5. Additional attacks = 5/2 = 2. Total points = 1 + 2 = 3.

example_2.py — Insufficient Energy

$ Input: enemyEnergies = [4,4], currentEnergy = 3

› Output: 0

💡 Note: We cannot attack any enemy since our current energy (3) is less than the minimum enemy energy (4). Therefore, we cannot gain any points.

example_3.py — Large Scale Battle

$ Input: enemyEnergies = [1,1,1,1], currentEnergy = 1

› Output: 7

💡 Note: Attack first enemy (energy 1): gain 1 point, energy becomes 0. Absorb remaining three enemies: energy becomes 0 + 1 + 1 + 1 = 3. Now we can attack the remaining enemies (all energy 1) three more times: 3/1 = 3. But wait, we need to be more careful. We attack one enemy of energy 1, then absorb the other 3 enemies. Total energy = 0 + 3 = 3. Additional attacks = 3/1 = 3. But we have 4 enemies total, so after first attack and 3 absorbs, we can attack the minimum energy (1) again: 3/1 = 3 more times. Total = 1 + 3 + 3 = 7 points.

Constraints

1 ≤ enemyEnergies.length ≤ 10⁵
1 ≤ enemyEnergies[i] ≤ 10⁹
0 ≤ currentEnergy ≤ 10⁹
All enemy energies are positive integers

Visualization

Tap to expand

Understanding the Visualization

Survey the Battlefield

Look at all enemies and identify the weakest one (minimum energy required)

Prove Yourself

Attack the weakest enemy to gain your first point and unlock absorption ability

Power Up

Absorb all remaining enemies to maximize your energy reserves

Maximize Rewards

Repeatedly attack the weakest enemy type to maximize total points earned

Key Takeaway

🎯 Key Insight: The greedy approach works because absorbing high-energy enemies gives us more 'fuel' to repeatedly attack the most efficient target (lowest energy enemy), maximizing our point generation rate.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a greedy strategy: find the enemy with minimum energy, attack it once to get your first point, then absorb all other enemies to maximize energy, and finally attack the minimum enemy repeatedly. This achieves O(n) time complexity and is mathematically proven to be optimal.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Strategy (Optimal)	O(n)	O(1)	Get first point with weakest enemy, absorb all others, then repeatedly attack weakest
Brute Force (Try All Sequences)	O(2^n)	O(n * E * P)	Try every possible sequence of attack and absorb operations

Greedy Strategy (Optimal) — Algorithm Steps

If we can't attack any enemy, return 0 points
Find the minimum energy enemy
Attack the minimum enemy once to get our first point
Absorb all other enemies to maximize energy
Calculate how many times we can attack the minimum enemy
Return total points = 1 + (total_energy / min_enemy)

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Minimum

Identify the enemy with minimum energy

First Attack

Attack the minimum enemy to get first point

Absorb All Others

Absorb remaining enemies to maximize energy

Repeat Attacks

Attack minimum enemy as many times as possible

Code -

solution.c — C

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

int maximumPoints(int* enemyEnergies, int n, int currentEnergy) {
    if (n == 0) return 0;
    
    int minEnemy = INT_MAX;
    int totalEnergy = 0;
    
    for (int i = 0; i < n; i++) {
        if (enemyEnergies[i] < minEnemy) {
            minEnemy = enemyEnergies[i];
        }
        totalEnergy += enemyEnergies[i];
    }
    
    // If we can't even attack the weakest enemy, return 0
    if (currentEnergy < minEnemy) return 0;
    
    // Attack the weakest enemy once to get our first point
    int points = 1;
    int energyAfterFirstAttack = currentEnergy - minEnemy;
    
    // Absorb all other enemies (except the one we just attacked)
    int totalAbsorbedEnergy = totalEnergy - minEnemy;
    int finalEnergy = energyAfterFirstAttack + totalAbsorbedEnergy;
    
    // Calculate additional points by repeatedly attacking the weakest enemy
    int additionalPoints = finalEnergy / minEnemy;
    
    return points + additionalPoints;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Simple parsing for [[1,2,3], 5] format
    int enemies[100], n = 0, currentEnergy;
    char* ptr = strchr(input, '[') + 1;
    
    while (*ptr != ']') {
        if (*ptr >= '0' && *ptr <= '9') {
            enemies[n++] = atoi(ptr);
            while (*ptr >= '0' && *ptr <= '9') ptr++;
        } else {
            ptr++;
        }
    }
    
    ptr = strchr(ptr, ',') + 1;
    currentEnergy = atoi(ptr);
    
    printf("%d\n", maximumPoints(enemies, n, currentEnergy));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to find minimum enemy and sum all energies

✓ Linear Growth

Space Complexity

O(1)

Only uses constant extra space for variables

✓ Linear Space

11.3K Views

Medium Frequency

~15 min Avg. Time

487 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

Greedy Strategy (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler