New 21 Game - Practice Coding Problems

New 21 Game - Problem

🎲 New 21 Game - Probability Challenge

Alice is playing an exciting card game loosely based on Blackjack (21)! Here's how it works:

🎯 Starting Point: Alice begins with 0 points
🎴 Drawing Rules: She draws cards while she has less than k points
🎲 Random Gain: Each draw gives her a random number of points from [1, maxPts] with equal probability
🛑 Stop Condition: She stops when she reaches k or more points

Your Mission: Calculate the probability that Alice ends up with n or fewer points when the game ends!

💡 Think of it like this: If Alice needs to reach at least k=10 points to stop, and can draw 1-3 points each turn, what's the chance she doesn't go over n=15 total points?

Input & Output

example_1.py — Simple Case

$ Input: n = 10, k = 1, maxPts = 10

› Output: 1.00000

💡 Note: Alice draws once (since k=1) and gets 1-10 points. All outcomes (1-10) are ≤ n=10, so probability = 1.0

example_2.py — Standard Game

$ Input: n = 6, k = 1, maxPts = 10

› Output: 0.60000

💡 Note: Alice draws once and gets 1-10 points. Only outcomes 1-6 are ≤ n=6, so probability = 6/10 = 0.6

example_3.py — Multi-Draw Game

$ Input: n = 21, k = 17, maxPts = 10

› Output: 0.73278

💡 Note: Alice must reach 17+ points, then stop. Complex probability calculation considering all paths that end with ≤ 21 points.

Visualization

Tap to expand

Understanding the Visualization

Initial State

Alice starts with 100% probability at score 0

Probability Distribution

Each draw distributes probability equally among next maxPts positions

Sliding Window

Efficiently track sum of probabilities that can contribute to current state

Final Accumulation

Sum probabilities for all valid ending scores (k ≤ score ≤ n)

Key Takeaway

🎯 Key Insight: The sliding window optimization transforms an exponential brute force solution into a linear-time algorithm by efficiently tracking probability distributions without redundant calculations.

Time & Space Complexity

Time Complexity

⏱️

O(n + k)

Single pass through all relevant scores with sliding window optimization

✓ Linear Growth

Space Complexity

O(n + k)

DP array to store probabilities for each possible score

⚡ Linearithmic Space

Constraints

0 ≤ k ≤ n ≤ 10⁴
1 ≤ maxPts ≤ 10⁴
Answer precision: within 10^-5 of actual answer

Asked in

G Google 23 a Amazon 18 ⊞ Microsoft 12 f Meta 8

The optimal solution uses Dynamic Programming with Sliding Window optimization. We maintain a DP array where dp[i] represents the probability of reaching exactly i points while still drawing. The key insight is using a sliding window to efficiently track the sum of probabilities from previous maxPts positions, achieving O(n) time complexity instead of the brute force O(maxPts^k) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Simulation (Brute Force)	O(maxPts^(k/avgDraw))	O(k)	Recursively simulate all possible game outcomes
Dynamic Programming with Sliding Window (Optimal)	O(n + k)	O(n + k)	Use DP array with sliding window optimization for efficient probability calculation

Recursive Simulation (Brute Force) — Algorithm Steps

Define recursive function calculate(currentScore)
Base case: if currentScore >= k, check if <= n
For each possible draw (1 to maxPts), recursively calculate probability
Average all outcomes and return weighted probability

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at 0

Begin with score 0, try all draws 1 to maxPts

Recursive calls

Each path branches into maxPts new recursive calls

Base cases

When score >= k, return 1 if score <= n, else 0

Code -

solution.c — C

#include <stdio.h>

double calculate(int score, int n, int k, int maxPts) {
    if (score >= k) {
        return score <= n ? 1.0 : 0.0;
    }
    
    double prob = 0.0;
    for (int draw = 1; draw <= maxPts; draw++) {
        prob += calculate(score + draw, n, k, maxPts);
    }
    
    return prob / maxPts;
}

double new21Game(int n, int k, int maxPts) {
    return calculate(0, n, k, maxPts);
}

int main() {
    int n, k, maxPts;
    scanf("%d %d %d", &n, &k, &maxPts);
    
    double result = new21Game(n, k, maxPts);
    printf("%.5f\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(maxPts^(k/avgDraw))

Exponential - explores all possible game sequences

✓ Linear Growth

Space Complexity

O(k)

Recursion stack depth proportional to maximum draws needed

✓ Linear Space

Constraints

0 ≤ k ≤ n ≤ 10⁴
1 ≤ maxPts ≤ 10⁴
Answer precision: within 10^-5 of actual answer

42.8K Views

Medium Frequency

~25 min Avg. Time

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

🎲 New 21 Game - Probability Challenge

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Recursive Simulation (Brute Force) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler