Toss Strange Coins

Toss Strange Coins - Problem

You have some coins. The i-th coin has a probability prob[i] of facing heads when tossed.

Return the probability that the number of coins facing heads equals target if you toss every coin exactly once.

Note: The answer should be accurate to within 10^-5 of the expected answer.

Input & Output

Example 1 — Basic Case

$ Input: prob = [0.4, 0.6], target = 1

› Output: 0.52

💡 Note: Two ways to get exactly 1 head: coin 1 heads + coin 2 tails (0.4 × 0.4 = 0.16) or coin 1 tails + coin 2 heads (0.6 × 0.6 = 0.36). Total: 0.16 + 0.36 = 0.52

Example 2 — All Heads

$ Input: prob = [0.5, 0.5, 0.5], target = 3

› Output: 0.125

💡 Note: Need all 3 coins to be heads: 0.5 × 0.5 × 0.5 = 0.125

Example 3 — Impossible Target

$ Input: prob = [0.2, 0.3], target = 5

› Output: 0.0

💡 Note: Cannot get 5 heads with only 2 coins, so probability is 0

Constraints

1 ≤ prob.length ≤ 1000
0 ≤ prob[i] ≤ 1
0 ≤ target ≤ prob.length
Answers within 10^-5 of expected answer will be accepted

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 M Microsoft 15

The key insight is to use dynamic programming to track probabilities incrementally. For each coin, we can either get heads (with probability prob[i]) or tails (with probability 1-prob[i]). Best approach is Bottom-Up DP with Time: O(n × target), Space: O(n × target).

Common Approaches

✓ Bottom-Up Dynamic Programming

⏱️ Time: O(n × target) Space: O(n × target)

Use a 2D DP table where dp[i][j] represents the probability of getting exactly j heads using the first i coins. Fill the table bottom-up, considering each coin's contribution to heads or tails.

Brute Force - All Combinations

⏱️ Time: O(2^n) Space: O(n)

For each coin, we have two outcomes: heads or tails. Generate all 2^n possible combinations, calculate the probability of each combination, and sum up probabilities where exactly target coins show heads.

Memoization - Top Down DP

⏱️ Time: O(n × target) Space: O(n × target)

Use recursion with memoization to store already computed probabilities for specific (coin_index, remaining_target) states. This eliminates redundant calculations in the brute force approach.

Bottom-Up Dynamic Programming — Algorithm Steps

Initialize dp[0][0] = 1.0 (0 heads with 0 coins)
For each coin, update all possible head counts
dp[i][j] = prob[i-1] * dp[i-1][j-1] + (1-prob[i-1]) * dp[i-1][j]
Return dp[n][target]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

dp[0][0] = 1.0 (base case)

Fill Table

For each coin, update all possible head counts

Result

dp[n][target] contains the final probability

Code -

solution.c — C

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

double solution(double* prob, int n, int target) {
    if (target > n) {
        return 0.0;
    }
    
    // dp[i][j] = probability of getting exactly j heads using first i coins
    double dp[1001][1001];
    memset(dp, 0, sizeof(dp));
    dp[0][0] = 1.0;
    
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j <= target; j++) {
            // Don't take heads from coin i-1
            dp[i][j] = (1 - prob[i-1]) * dp[i-1][j];
            // Take heads from coin i-1
            if (j > 0) {
                dp[i][j] += prob[i-1] * dp[i-1][j-1];
            }
        }
    }
    
    return dp[n][target];
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse array
    double prob[1000];
    int n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        prob[n++] = atof(token);
        token = strtok(NULL, ",]");
    }
    
    int target;
    scanf("%d", &target);
    
    double result = solution(prob, n, target);
    printf("%f\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × target)

Fill n × target DP table, each cell computed in O(1)

✓ Linear Growth

Space Complexity

O(n × target)

2D DP table stores probability for each (coins, heads) combination

⚡ Linearithmic Space

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