Bag of Tokens - Practice Coding Problems

Bag of Tokens - Problem

Bag of Tokens - A Strategic Power and Score Management Problem

You're a strategic game player starting with an initial power value and a score of 0. You have a bag containing various tokens, each with a specific power value represented in the array tokens.

Your objective is to maximize your final score by strategically playing these tokens in one of two ways:

🔥 Face-Up Play: If your current power ≥ tokens[i], you can spend tokens[i] power to gain 1 score point

💰 Face-Down Play: If your current score ≥ 1, you can spend 1 score point to gain tokens[i] power

Each token can only be played once, and you must choose the optimal sequence of moves to achieve the maximum possible score.

Input & Output

example_1.py — Basic Token Strategy

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

› Output: 2

💡 Note: Play token 100 face-up (power=100, score=1), play token 400 face-down (power=500, score=0), play token 200 face-up (power=300, score=1), play token 300 face-up (power=0, score=2). Maximum score is 2.

example_2.py — Insufficient Power

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

› Output: 1

💡 Note: Play token 100 face-up (power=50, score=1). Cannot play token 200 face-up due to insufficient power, and cannot play face-down since we need score≥1. Maximum score is 1.

example_3.py — Empty Tokens

$ Input: tokens = [], power = 85

› Output: 0

💡 Note: No tokens available to play, so the maximum score remains 0.

Constraints

0 ≤ tokens.length ≤ 1000
0 ≤ tokens[i], power < 10⁴
Each token can only be used once
Score starts at 0 and power is given as input

Visualization

Tap to expand

Understanding the Visualization

Sort by Value

Arrange tokens from cheapest to most expensive

Greedy Face-Up

Always buy points using the cheapest available tokens

Strategic Face-Down

When power is low but you have points, sell a point for maximum power using the most expensive token

Track Maximum

Keep track of the highest score achieved throughout the process

Key Takeaway

🎯 Key Insight: Sort tokens and use greedy strategy - cheapest for scoring, most expensive for power recovery. This maximizes efficiency at each step.

Asked in

G Google 45 a Amazon 38 f Meta 25 ⊞ Microsoft 22

The optimal solution uses a greedy two-pointer approach after sorting the tokens. The key insight is to always play the smallest tokens face-up to maximize scoring efficiency, and play the largest tokens face-down to maximize power gain when needed. This achieves O(n log n) time complexity with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(3^n)	O(n)	Try every possible sequence of token plays using recursion
Two Pointers (Greedy Optimal)	O(n log n)	O(1)	Sort tokens and use greedy strategy with two pointers from both ends

Brute Force (Try All Combinations) — Algorithm Steps

Use recursion to try all possible token play sequences
At each step, try playing each remaining token face-up or face-down
Track current power, score, and used tokens
Return maximum score found across all valid sequences

Visualization

Tap to expand

Step-by-Step Walkthrough

Start State

Begin with initial power and score of 0

Branch Decisions

For each token, create branches for face-up, face-down, or skip

Explore All Paths

Recursively explore every possible sequence

Find Maximum

Return the path that yields highest score

Code -

solution.c — C

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

int backtrack(int* tokens, int size, int index, int currentPower, int currentScore, int* used) {
    int maxScore = currentScore;
    
    for (int i = index; i < size; i++) {
        if (used[i]) continue;
        
        // Try face-up play
        if (currentPower >= tokens[i]) {
            used[i] = 1;
            int score = backtrack(tokens, size, i + 1, currentPower - tokens[i], currentScore + 1, used);
            if (score > maxScore) maxScore = score;
            used[i] = 0;
        }
        
        // Try face-down play
        if (currentScore >= 1) {
            used[i] = 1;
            int score = backtrack(tokens, size, i + 1, currentPower + tokens[i], currentScore - 1, used);
            if (score > maxScore) maxScore = score;
            used[i] = 0;
        }
    }
    
    return maxScore;
}

int bagOfTokensScore(int* tokens, int tokensSize, int power) {
    int* used = (int*)calloc(tokensSize, sizeof(int));
    int result = backtrack(tokens, tokensSize, 0, power, 0, used);
    free(used);
    return result;
}

int main() {
    int tokens[] = {100, 200, 300, 400};
    int power = 200;
    printf("%d\n", bagOfTokensScore(tokens, 4, power));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

For each token, we have 3 choices: play face-up, face-down, or not play. This creates exponential combinations.

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth and tracking used tokens

⚡ Linearithmic Space

73.9K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler