Maximum Number of Coins You Can Get - Problem

Array Math Greedy Sorting Game Theory Medium

There are 3n piles of coins of varying size. You and your friends Alice and Bob will take piles of coins following this process:

In each step, you choose any 3 piles of coins (not necessarily consecutive)
Alice picks the pile with the maximum number of coins
You pick the pile with the next maximum number of coins
Bob picks the remaining pile
Repeat until no piles remain

Given an array piles where piles[i] is the number of coins in the i^th pile, return the maximum number of coins you can collect.

Input & Output

Example 1 — Basic Game

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

› Output: 9

💡 Note: Sort: [8,7,4,2,2,1]. Take positions 2,3: piles[2]=4, piles[3]=2. Total: 4+2=6. Wait, let me recalculate: n=2, take indices 2 to 3, which gives 4+2=6. But optimal is: Alice gets 8,7 and you get 4,2, Bob gets 2,1. Actually, you get 7+2=9.

Example 2 — Larger Array

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

› Output: 14

💡 Note: Sort: [9,8,7,6,5,1]. Take every second position starting from 1: piles[1]=8, piles[3]=6. Total: 8+6=14

Example 3 — Equal Values

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

› Output: 2

💡 Note: All piles equal, sort doesn't change order. Take every second position starting from 1: piles[1]=1, piles[3]=1. Total: 1+1=2

Constraints

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

Visualization

Tap to expand

Asked in

f Facebook 15 G Google 12 a Amazon 8

The key insight is to sort the piles and use a greedy strategy. After sorting in descending order, take every element from position n to 2n-1. This ensures Alice gets the largest piles, you get the next best, and Bob gets the smallest. Best approach is greedy sorting. Time: O(n log n), Space: O(1)

Common Approaches

✓ Memoization

⏱️ Time: N/A Space: N/A

Dp 2d

⏱️ Time: N/A Space: N/A

Greedy Strategy (Sort First)

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

Sort all piles in descending order, then strategically pick triplets to force Alice to compete with the largest remaining pile while you get good middle values.

Try All Combinations

⏱️ Time: O((3n)!) Space: O(n)

For each possible way to divide the 3n piles into n groups of 3, simulate the game where Alice takes max, you take middle, Bob takes min from each group.

Algorithm Steps — Algorithm Steps

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 solution(int* piles, int pilesSize) {
    // Sort in descending order
    qsort(piles, pilesSize, sizeof(int), compare);
    
    int result = 0;
    int n = pilesSize / 3;
    
    // Take every second element starting from index 1
    // This gives us the second maximum in each optimal group of 3
    for (int i = 1; i < 2 * n; i += 2) {
        result += piles[i];
    }
    
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    
    // Find the opening bracket
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse numbers until closing bracket
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Parse the number
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int piles[1000], pilesSize = 0;
    parseArray(line, piles, &pilesSize);
    
    printf("%d\n", solution(piles, pilesSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.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