Bag of Tokens

Bag of Tokens - Problem

You start with an initial power of power, an initial score of 0, and a bag of tokens given as an integer array tokens, where each tokens[i] denotes the value of token i.

Your goal is to maximize the total score by strategically playing these tokens. In one move, you can play an unplayed token in one of the two ways (but not both for the same token):

Face-up: If your current power is at least tokens[i], you may play token i, losing tokens[i] power and gaining 1 score.

Face-down: If your current score is at least 1, you may play token i, gaining tokens[i] power and losing 1 score.

Return the maximum possible score you can achieve after playing any number of tokens.

Input & Output

Example 1 — Basic Strategy

$ Input: tokens = [100,200,300,400], power = 200

› Output: 2

💡 Note: Sort tokens to [100,200,300,400]. Play 100 face-up (power=100, score=1). Can't play 200 face-up with remaining power, so play 400 face-down (power=500, score=0). Now play 200 face-up (power=300, score=1) and 300 face-up (power=0, score=2). Maximum achievable score is 2.

Example 2 — Face-down Strategy

$ Input: tokens = [100], power = 50

› Output: 0

💡 Note: We don't have enough power (50) to play the token (100) face-up, and we don't have any score to play it face-down, so maximum score is 0.

Example 3 — Mixed Strategy

$ Input: tokens = [200,100], power = 150

› Output: 1

💡 Note: Sort tokens to [100,200]. Play token 100 face-up (power becomes 50, score becomes 1). We can't play 200 face-up as we don't have enough power, so max score is 1.

Constraints

0 ≤ tokens.length ≤ 1000
0 ≤ tokens[i], power < 10⁴

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is to sort tokens and use a greedy two-pointer approach: play the cheapest tokens face-up to maximize score, and play the most expensive tokens face-down when we need more power. Best approach is greedy with sorting. Time: O(n log n), Space: O(1)

Common Approaches

✓ Stack

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

Brute Force - Try All Combinations

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

For each unplayed token, recursively try both playing it face-up (if we have enough power) and face-down (if we have enough score), then take the maximum score achievable.

Greedy with Two Pointers

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

Sort the tokens, then use two pointers to greedily play the cheapest tokens face-up to gain score, and play the most expensive tokens face-down to gain power when needed.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

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

int solution(int tokens[], int n, int power) {
    qsort(tokens, n, sizeof(int), compare);
    int left = 0, right = n - 1;
    int score = 0;
    int maxScore = 0;
    
    while (left <= right) {
        // If we can play the cheapest token face-up
        if (power >= tokens[left]) {
            power -= tokens[left];
            score += 1;
            left += 1;
            if (score > maxScore) {
                maxScore = score;
            }
        } else if (score > 0 && left < right) {
            // Play most expensive token face-down to gain power
            power += tokens[right];
            score -= 1;
            right -= 1;
        } else {
            // Can't make any beneficial move
            break;
        }
    }
    
    return maxScore;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int tokens[1000];
    int n = 0;
    
    // Parse JSON array format: [num1,num2,num3]
    char* ptr = line;
    
    // Skip opening bracket and whitespace
    while (*ptr && (*ptr == '[' || isspace(*ptr))) ptr++;
    
    while (*ptr && *ptr != ']' && n < 1000) {
        // Skip whitespace and commas
        while (*ptr && (*ptr == ',' || isspace(*ptr))) ptr++;
        
        if (*ptr == ']') break;
        
        // Parse number
        tokens[n] = (int)strtol(ptr, &ptr, 10);
        n++;
    }
    
    // Read power
    fgets(line, sizeof(line), stdin);
    int power = atoi(line);
    
    int result = solution(tokens, n, power);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

856 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