Maximum Number of Coins You Can Get - Practice Coding Problems

Maximum Number of Coins You Can Get - Problem

Array Math Greedy Sorting Game Theory Medium

Coin Collection Game - Strategic Optimization

You're playing an exciting coin collection game with your friends Alice and Bob! 🪙

Game Rules:
• There are 3n piles of coins with different amounts
• In each round, you choose any 3 piles
• Alice (being greedy) always takes the pile with the most coins
• You get the pile with the second-most coins
• Poor Bob gets stuck with the smallest pile
• This continues until all piles are taken

Your Mission: Choose the 3-pile combinations strategically to maximize the total coins you collect!

Input: An array piles where piles[i] represents the number of coins in pile i
Output: The maximum number of coins you can obtain

Example: With piles [2,4,1,2,7,8], you can get 9 coins by smart selection!

Input & Output

example_1.py — Basic Game

$ Input: piles = [2,4,1,2,7,8]

› Output: 9

💡 Note: Choose triplets optimally: (8,7,1) gives you 7, (4,2,2) gives you 2. Total = 7+2 = 9 coins. Alice gets 8+4=12, Bob gets 1+2=3.

example_2.py — Larger Array

$ Input: piles = [9,8,7,6,5,1,2,3,4]

› Output: 18

💡 Note: After sorting: [9,8,7,6,5,4,3,2,1]. Form triplets (9,8,1), (7,6,2), (5,4,3). You get positions 1,3,5: 8+6+4 = 18 coins.

example_3.py — Minimum Case

$ Input: piles = [1,100,3]

› Output: 3

💡 Note: Only one triplet possible: (100,3,1). Alice takes 100, you get 3, Bob gets 1. Your total is 3 coins.

Visualization

Tap to expand

Understanding the Visualization

Sort All Treasures

Arrange all treasure chests from most valuable to least valuable

Identify Your Targets

Your optimal chests are at positions 1, 3, 5... (every second position)

Strategic Pairing

Pair each of your targets with the best available chest (positions 0, 2, 4...)

Sacrifice Strategy

Let the weakest player take the smallest chests to maximize your total

Key Takeaway

🎯 Key Insight: Since Alice always takes the maximum pile from each triplet, pair your desired piles (second-largest) with the absolute best piles available. This greedy strategy after sorting guarantees optimal results!

Time & Space Complexity

Time Complexity

⏱️

O((3n)!/(3!)^n)

We need to generate all ways to partition 3n items into groups of 3, which is multinomial coefficient

✓ Linear Growth

Space Complexity

O(n)

Space for recursion stack and storing current partition

⚡ Linearithmic Space

Constraints

3 ≤ piles.length ≤ 10⁵
piles.length % 3 == 0
1 ≤ piles[i] ≤ 10⁴

Asked in

G Google 15 a Amazon 12 Apple 8 ⊞ Microsoft 6

The optimal solution uses a greedy approach: sort piles in descending order, then take every second element starting from position 1. Since Alice always picks the maximum from each triplet you choose, pair your target piles with the largest available piles to maximize your gains. Time: O(n log n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O((3n)!/(3!)^n)	O(n)	Generate all possible ways to group piles into triplets and find maximum coins
Greedy + Sorting (Optimal)	O(n log n)	O(1)	Sort piles and greedily pair largest piles with our target piles

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible ways to partition 3n piles into n groups of 3
For each partition, simulate the game: Alice gets max, we get second-max, Bob gets min
Calculate total coins we obtain in each partition
Return the maximum total across all partitions

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Partitions

Create all possible ways to group 3n piles into n triplets

Simulate Game

For each partition, Alice takes max, we take second-max, Bob takes min

Calculate Total

Sum up all coins we collect across all triplets

Find Maximum

Return the partition that gives us the most coins

Code -

solution.c — C

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

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

int findMaxCoins(int* piles, int size) {
    if (size == 3) {
        qsort(piles, 3, sizeof(int), compare);
        return piles[1];
    }
    
    int maxCoins = 0;
    
    // Try all combinations of 3 piles
    for (int i = 0; i < size; i++) {
        for (int j = i + 1; j < size; j++) {
            for (int k = j + 1; k < size; k++) {
                int triplet[3] = {piles[i], piles[j], piles[k]};
                qsort(triplet, 3, sizeof(int), compare);
                int currentCoins = triplet[1];
                
                int* remaining = (int*)malloc((size - 3) * sizeof(int));
                int idx = 0;
                for (int l = 0; l < size; l++) {
                    if (l != i && l != j && l != k) {
                        remaining[idx++] = piles[l];
                    }
                }
                
                currentCoins += findMaxCoins(remaining, size - 3);
                if (currentCoins > maxCoins) {
                    maxCoins = currentCoins;
                }
                
                free(remaining);
            }
        }
    }
    
    return maxCoins;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Parse input [1,2,3,4] format
    int piles[100];
    int size = 0;
    
    char* token = strtok(input, "[,]");
    while (token != NULL) {
        piles[size++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    printf("%d\n", findMaxCoins(piles, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((3n)!/(3!)^n)

We need to generate all ways to partition 3n items into groups of 3, which is multinomial coefficient

✓ Linear Growth

Space Complexity

O(n)

Space for recursion stack and storing current partition

⚡ Linearithmic Space

Constraints

3 ≤ piles.length ≤ 10⁵
piles.length % 3 == 0
1 ≤ piles[i] ≤ 10⁴

47.2K Views

Medium Frequency

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler