Maximum Score From Removing Stones - Practice Coding Problems

Maximum Score From Removing Stones - Problem

Imagine you're playing a strategic stone removal game with three piles of stones containing a, b, and c stones respectively.

The rules are simple but require strategy:

Each turn, you must choose two different non-empty piles
Remove exactly one stone from each of the chosen piles
Earn 1 point for each successful move
The game ends when you have fewer than two non-empty piles remaining

Your goal is to maximize your score by making optimal moves. The key insight is that you want to keep playing as long as possible, which means balancing the piles strategically.

Example: With piles [2, 4, 6], you could potentially make up to 6 moves by always picking stones from the two largest piles, resulting in a maximum score of 6.

Input & Output

example_1.py — Basic Case

$ Input: a = 2, b = 4, c = 6

› Output: 6

💡 Note: Total stones = 12. Max pile = 6, others = 6. Since 6 ≤ 6, we can make 12/2 = 6 moves. Optimal strategy: always pick from the two largest piles.

example_2.py — Imbalanced Case

$ Input: a = 4, b = 4, c = 2

› Output: 4

💡 Note: Total stones = 10. Max pile = 4, others = 6. Since 4 ≤ 6, we can make 10/2 = 5 moves... wait, let's verify: (4,4,2) → (3,3,2) → (2,2,2) → (1,1,2) → (0,0,2). Actually 4 moves, limited by balance.

example_3.py — Edge Case

$ Input: a = 1, b = 8, c = 8

› Output: 8

💡 Note: Total stones = 17. Max pile = 8, others = 9. Since 8 ≤ 9, we can make 17/2 = 8 moves (integer division). The large pile doesn't dominate completely.

Constraints

0 ≤ a, b, c ≤ 10⁵
At least one pile must be non-empty
Time limit: 1 second per test case

Visualization

Tap to expand

Understanding the Visualization

Identify the Strategy

Always remove from the two largest piles to maximize game duration

Check for Limitations

Determine if one pile is so large it limits our total moves

Calculate Maximum

Use the mathematical formula to get the answer instantly

Key Takeaway

🎯 Key Insight: Always pick from the two largest piles to maximize the number of moves. The mathematical formula gives us the answer instantly without simulation.

Asked in

G Google 25 a Amazon 18 Apple 15 ⊞ Microsoft 12

The optimal solution uses a mathematical greedy approach with O(1) time complexity. The key insight is that the maximum score is min(total/2, sum_of_two_smallest_piles). This works because we're either limited by the total stones we can remove (when piles are balanced) or by running out of stones in the smaller piles (when one pile dominates).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(a + b + c)	O(1)	Simulate the game by always picking stones from the two largest piles
Mathematical Greedy Solution	O(1)	O(1)	Use mathematical insight to calculate the answer directly without simulation

Brute Force Simulation — Algorithm Steps

Initialize score to 0
While at least two piles are non-empty:
Find the two largest piles
Remove one stone from each
Increment score
Return the final score

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with three piles of different sizes

Find Largest Two

Identify the two piles with the most stones

Remove Stones

Take one stone from each of the two largest piles

Repeat

Continue until fewer than two piles remain non-empty

Code -

solution.c — C

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

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

int maximumScore(int a, int b, int c) {
    int score = 0;
    int piles[3] = {a, b, c};
    
    while (1) {
        qsort(piles, 3, sizeof(int), compare);
        if (piles[1] == 0) break;
        
        piles[0]--;
        piles[1]--;
        score++;
    }
    
    return score;
}

int main() {
    int a, b, c;
    scanf("%d %d %d", &a, &b, &c);
    printf("%d\n", maximumScore(a, b, c));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(a + b + c)

We perform at most (a + b + c)/2 iterations, each taking constant time to find max elements

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track pile sizes and score

✓ Linear Space

23.5K Views

Medium Frequency

~15 min Avg. Time

847 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler