Toss Strange Coins - Practice Coding Problems

Toss Strange Coins - Problem

You are conducting a fascinating probability experiment with strange coins! Each coin has its own unique probability of landing heads when tossed. Given an array prob where prob[i] represents the probability that the i-th coin shows heads, you need to calculate the probability that exactly target coins will show heads when you toss all coins once.

For example, if you have 3 coins with probabilities [0.4, 0.5, 0.1] and want exactly 1 head, you need to consider all possible ways to get exactly 1 head and sum their probabilities.

Goal: Return the probability (as a decimal) that exactly target coins will show heads.

Input & Output

example_1.py — Python

$ Input: prob = [0.4, 0.5, 0.1], target = 1

› Output: 0.48

💡 Note: There are 3 ways to get exactly 1 head: HTT (0.4×0.5×0.9=0.18), THT (0.6×0.5×0.9=0.27), TTH (0.6×0.5×0.1=0.03). Total: 0.18+0.27+0.03=0.48

example_2.py — Python

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

› Output: 0.375

💡 Note: With 3 fair coins wanting 2 heads: HHT, HTH, THH each have probability 0.5×0.5×0.5=0.125. Total: 3×0.125=0.375

example_3.py — Python

$ Input: prob = [1.0], target = 1

› Output: 1.0

💡 Note: Edge case: With one coin that always shows heads, the probability of getting exactly 1 head is 1.0

Visualization

Tap to expand

Understanding the Visualization

Start with Certainty

Begin with 100% probability of 0 heads

First Coin Split

Probability splits: some flows to 1 head, rest stays at 0 heads

Continue Cascade

Each subsequent coin further splits and redistributes probabilities

Final Collection

Collect the probability that flows to exactly the target number of heads

Key Takeaway

🎯 Key Insight: Dynamic programming transforms an exponential problem into a polynomial one by building probabilities incrementally rather than enumerating all possible outcomes.

Time & Space Complexity

Time Complexity

⏱️

O(n * target)

We process each of n coins and for each coin, we update at most target+1 probability values

✓ Linear Growth

Space Complexity

O(target)

We can optimize space by using only two arrays of size target+1, or even one array with careful updating

✓ Linear Space

Constraints

1 ≤ prob.length ≤ 1000
0 ≤ prob[i] ≤ 1
0 ≤ target ≤ prob.length
Answers within 10^-5 of the actual value will be accepted as correct

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal solution uses dynamic programming with O(n×target) time complexity. We maintain a DP table where dp[j] represents the probability of getting exactly j heads. For each coin, we update the probabilities by considering both heads and tails outcomes, building the final answer incrementally.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n * target)	O(target)	Build probability table incrementally using dynamic programming

Dynamic Programming (Optimal) — Algorithm Steps

Initialize DP table: dp[i][j] = probability of j heads using first i coins
Base case: dp[0][0] = 1 (0 heads with 0 coins has probability 1)
For each coin i and each possible head count j:
Update dp[i+1][j] from tails: dp[i+1][j] += dp[i][j] * (1-prob[i])
Update dp[i+1][j+1] from heads: dp[i+1][j+1] += dp[i][j] * prob[i]
Return dp[n][target]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP Table

Start with dp[0] = 1.0 (probability of 0 heads is 1)

Process Each Coin

For each coin, update probabilities considering heads/tails outcomes

Final Result

dp[target] contains the final probability

Code -

solution.c — C

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

double probabilityOfHeads(double* prob, int n, int target) {
    if (target > n) return 0.0;
    
    // dp[j] = probability of getting exactly j heads
    double* dp = calloc(target + 1, sizeof(double));
    dp[0] = 1.0; // Base case
    
    for (int i = 0; i < n; i++) {
        // Process from right to left to avoid overwriting
        int maxJ = (i + 1 < target) ? i + 1 : target;
        for (int j = maxJ; j >= 0; j--) {
            double probHeads = (j > 0) ? dp[j] * prob[i] : 0.0;
            double probTails = dp[j] * (1 - prob[i]);
            
            // Update probability for j+1 heads
            if (j < target) {
                dp[j + 1] += probHeads;
            }
            
            // Update probability for j heads (tails case)
            dp[j] = probTails;
        }
    }
    
    double result = dp[target];
    free(dp);
    return result;
}

int main() {
    double prob[] = {0.4, 0.5, 0.1};
    int target = 1;
    printf("%.10f\n", probabilityOfHeads(prob, 3, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * target)

We process each of n coins and for each coin, we update at most target+1 probability values

✓ Linear Growth

Space Complexity

O(target)

We can optimize space by using only two arrays of size target+1, or even one array with careful updating

✓ Linear Space

Constraints

1 ≤ prob.length ≤ 1000
0 ≤ prob[i] ≤ 1
0 ≤ target ≤ prob.length
Answers within 10^-5 of the actual value will be accepted as correct

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler