Maximum Score From Removing Stones

Maximum Score From Removing Stones - Problem

You are playing a solitaire game with three piles of stones of sizes a, b, and c respectively.

Each turn you choose two different non-empty piles, take one stone from each, and add 1 point to your score. The game stops when there are fewer than two non-empty piles (meaning there are no more available moves).

Given three integers a, b, and c, return the maximum score you can get.

Input & Output

Example 1 — Balanced Case

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

› Output: 6

💡 Note: We can take stones from different piles: (6,4), (5,3), (4,2), (3,2), (2,1), (1,1) → 6 moves total

Example 2 — Unbalanced Case

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

› Output: 7

💡 Note: Total = 14, so max possible is 7. Two smaller piles sum to 8, so we can achieve 7 points

Example 3 — Large Pile Dominates

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

› Output: 8

💡 Note: Limited by sum of two smaller piles: min(17/2, 1+8) = min(8, 9) = 8

Constraints

1 ≤ a, b, c ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that maximum score is limited by either total stones divided by 2 (when piles are balanced) or the sum of two smaller piles (when one pile dominates). Best approach uses mathematical formula for O(1) solution. Time: O(1), Space: O(1)

Common Approaches

✓ Greedy Strategy

⏱️ Time: O(n) Space: O(1)

Use a greedy approach where we repeatedly take stones from the two largest piles. This naturally balances the piles and maximizes the number of moves possible.

Mathematical Formula

⏱️ Time: O(1) Space: O(1)

The key insight is that maximum score is limited by either the total stones divided by 2, or the sum of the two smaller piles (when one pile is much larger than others).

Simulation with Priority Queue

⏱️ Time: O(n log n) Space: O(1)

Use a max heap to always select the two largest piles, remove one stone from each, and continue until fewer than two piles remain non-empty. Count the number of moves made.

Greedy Strategy — Algorithm Steps

Sort the three values
While at least two piles are non-empty
Take from two largest piles
Continue until game ends

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort

Identify two largest piles

Take

Remove one stone from each

Repeat

Continue until less than 2 piles remain

Code -

solution.c — C

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

void sortDesc(int arr[], int n) {
    for (int i = 0; i < n-1; i++) {
        for (int j = 0; j < n-i-1; j++) {
            if (arr[j] < arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

int solution(int a, int b, int c) {
    int score = 0;
    
    while (1) {
        // Sort to get largest two
        int piles[3] = {a, b, c};
        sortDesc(piles, 3);
        
        // Check if we can make a move
        if (piles[1] == 0) {
            break;
        }
        
        // Take from two largest
        piles[0]--;
        piles[1]--;
        score++;
        
        // Update variables
        a = piles[0];
        b = piles[1];
        c = piles[2];
    }
    
    return score;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

We make at most sum(a,b,c)/2 moves, each move is O(1) with simple comparisons

✓ Linear Growth

Space Complexity

O(1)

Only uses three variables to track pile sizes

✓ Linear Space

28.5K Views

Medium Frequency

~15 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

Greedy Strategy — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler