New 21 Game

New 21 Game - Problem

Alice plays a game loosely based on the card game 21. She starts with 0 points and draws numbers while she has less than k points.

During each draw, she gains an integer number of points randomly from the range [1, maxPts], where maxPts is an integer. Each draw is independent and the outcomes have equal probabilities.

Alice stops drawing numbers when she gets k or more points. Return the probability that Alice has n or fewer points.

Answers within 10⁻⁵ of the actual answer are considered accepted.

Input & Output

Example 1 — Basic Case

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

› Output: 0.73278

💡 Note: Alice draws until reaching 17+ points. She needs to end with ≤21 points. Most outcomes from 17-26 points are ≤21, giving high probability.

Example 2 — Edge Case

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

› Output: 0.60000

💡 Note: Alice stops after first draw (≥1 point). Draws 1-6 are valid (6 outcomes), draws 7-10 exceed n (4 outcomes). Probability = 6/10 = 0.6.

Example 3 — Guaranteed Win

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

› Output: 1.00000

💡 Note: From any score 14-16, Alice draws 1-3 points, reaching 17-19. All outcomes ≤21, so probability is 1.0.

Constraints

0 ≤ k ≤ n ≤ 10⁴
1 ≤ maxPts ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 8 M Microsoft 6

The key insight is that Alice stops drawing when reaching k points, so we need to calculate the probability distribution of final scores. The optimal sliding window DP approach maintains a running sum of transition probabilities, achieving O(n + k) time complexity instead of O(k × maxPts).

Common Approaches

✓ Bottom-Up Dynamic Programming

⏱️ Time: O(k × maxPts) Space: O(n + k)

Create a DP array where dp[i] represents the probability of reaching score i. Build from smallest scores to largest, calculating each score's probability based on previous scores.

Memoized Recursion

⏱️ Time: O(n × maxPts) Space: O(n + k)

Same recursive approach but cache results for each score to avoid redundant calculations. This transforms exponential time into polynomial time.

Recursive Simulation

⏱️ Time: O(maxPts^k) Space: O(k)

For each possible score, recursively calculate the probability of reaching that score and whether it leads to a winning outcome (≤ n points).

Sliding Window DP Optimization

⏱️ Time: O(n + k) Space: O(n + k)

Instead of calculating each transition in O(maxPts) time, maintain a sliding window sum of the last maxPts probabilities to achieve O(1) per transition.

Bottom-Up Dynamic Programming — Algorithm Steps

Initialize dp[0] = 1.0 (start with probability 1)
For each score i from 0 to k-1, distribute probability to i+1, i+2, ..., i+maxPts
Sum probabilities for all scores from k to n as the answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with dp[0] = 1.0, all others = 0

Propagate

For each score < k, distribute probability to next possible scores

Sum Result

Add up probabilities for scores k to n

Code -

solution.c — C

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

double solution(int n, int k, int maxPts) {
    if (k == 0) {
        return n >= 0 ? 1.0 : 0.0;
    }
    
    // dp[i] = probability of reaching score i
    double* dp = (double*)calloc(n + maxPts + 1, sizeof(double));
    dp[0] = 1.0;
    
    // Build probabilities for scores 0 to k-1
    for (int i = 0; i < k; i++) {
        if (dp[i] > 0) {
            for (int j = 1; j <= maxPts; j++) {
                if (i + j <= n + maxPts) {
                    dp[i + j] += dp[i] / maxPts;
                }
            }
        }
    }
    
    // Sum probabilities for scores k to n
    double result = 0.0;
    int maxIdx = n < n + maxPts ? n : n + maxPts;
    for (int i = k; i <= maxIdx; i++) {
        result += dp[i];
    }
    
    free(dp);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(k × maxPts)

For each score from 0 to k-1, we try maxPts transitions

✓ Linear Growth

Space Complexity

O(n + k)

DP array stores probabilities for scores up to n+maxPts

⚡ Linearithmic Space

28.0K Views

Medium Frequency

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler