Probability Pitfall – Uniformity Assumption Tanked CTR

# === Basic Probability: Die Roll and Coin Toss Examples ===
# Run this to see the core formula in action with real numbers.

def probability(favourable_outcomes, total_outcomes):
    """Returns probability as a decimal and a readable fraction string."""
    if total_outcomes == 0:
        raise ValueError("Total outcomes cannot be zero — that's not a valid sample space.")
    prob = favourable_outcomes / total_outcomes
    return prob, f"{favourable_outcomes}/{total_outcomes}"

# --- Example 1: Rolling a fair six-sided die ---
# Event: getting an even number (2, 4, or 6)
total_die_faces = 6
even_faces = [2, 4, 6]          # these are our favourable outcomes
favourable_even = len(even_faces)

prob_decimal, prob_fraction = probability(favourable_even, total_die_faces)
print(f"P(rolling an even number) = {prob_fraction} = {prob_decimal:.4f}")

# --- Example 2: Drawing a card — Addition Rule (OR) ---
# Event: drawing a King OR a Heart from a standard 52-card deck
# Kings: 4 cards. Hearts: 13 cards. BUT King of Hearts is in both — avoid double-counting!
total_cards = 52
kings = 4
hearts = 13
king_of_hearts = 1              # the overlap between the two groups

# P(King OR Heart) = P(King) + P(Heart) - P(King AND Heart)
favourable_king_or_heart = kings + hearts - king_of_hearts  # = 16
prob_king_or_heart = favourable_king_or_heart / total_cards
print(f"\nP(King OR Heart) = {favourable_king_or_heart}/{total_cards} = {prob_king_or_heart:.4f}")

# --- Example 3: Tossing two fair coins — Multiplication Rule (AND) ---
# Event: getting Heads on both coins
# The coins are independent — first coin result does NOT affect the second
p_heads_coin1 = 1 / 2          # P(Heads) on a fair coin
p_heads_coin2 = 1 / 2          # same, independent event

p_both_heads = p_heads_coin1 * p_heads_coin2   # multiply because AND + independent
print(f"\nP(Heads AND Heads) = 1/2 × 1/2 = {p_both_heads:.4f}")

# Sanity check: list every possible outcome
all_outcomes = [(c1, c2) for c1 in ['H', 'T'] for c2 in ['H', 'T']]
favourable = [o for o in all_outcomes if o == ('H', 'H')]
print(f"All outcomes: {all_outcomes}")
print(f"Favourable outcomes: {favourable}")
print(f"P(HH) by counting = {len(favourable)}/{len(all_outcomes)} = {len(favourable)/len(all_outcomes):.4f}")

# === Replacement vs No-Replacement: Cards and Marbles ===

import math

# --- Scenario: Drawing 2 Aces from a 52-card deck ---

# WITH REPLACEMENT: deck is reset after each draw — draws are independent
p_first_ace_with = 4 / 52       # 4 aces in 52 cards
p_second_ace_with = 4 / 52     # deck is restored — still 4 aces in 52
p_two_aces_with_replacement = p_first_ace_with * p_second_ace_with
print("=== WITH REPLACEMENT ===")
print(f"P(1st Ace)  = 4/52 = {p_first_ace_with:.6f}")
print(f"P(2nd Ace)  = 4/52 = {p_second_ace_with:.6f}  (deck unchanged)")
print(f"P(Two Aces) = {p_two_aces_with_replacement:.6f}")

print()

# WITHOUT REPLACEMENT: first ace is removed — second draw sees 51 cards, 3 aces
p_first_ace_without = 4 / 52   # 4 aces in 52 cards
p_second_ace_without = 3 / 51  # 3 aces remain in 51 remaining cards — KEY CHANGE
p_two_aces_no_replacement = p_first_ace_without * p_second_ace_without
print("=== WITHOUT REPLACEMENT ===")
print(f"P(1st Ace)         = 4/52 = {p_first_ace_without:.6f}")
print(f"P(2nd Ace | 1st was Ace) = 3/51 = {p_second_ace_without:.6f}  (deck shrinks!)")
print(f"P(Two Aces)        = {p_two_aces_no_replacement:.6f}")

print()
print(f"Difference between methods: {abs(p_two_aces_with_replacement - p_two_aces_no_replacement):.6f}")
print("(Ignoring replacement makes you ~14% over-confident in this case)")

print()
# --- Marble Bag Problem (classic aptitude style) ---
# Bag contains: 5 red, 3 blue, 2 green marbles (10 total)
# Q: P(drawing red then blue) WITHOUT replacement?

total_marbles = 10
red_marbles = 5
blue_marbles = 3

p_red_first = red_marbles / total_marbles          # 5/10
p_blue_second_given_red = blue_marbles / (total_marbles - 1)  # 3/9 — one red is gone

p_red_then_blue = p_red_first * p_blue_second_given_red
print("=== MARBLE BAG (No Replacement) ===")
print(f"P(Red first)          = {red_marbles}/{total_marbles} = {p_red_first:.4f}")
print(f"P(Blue second | Red)  = {blue_marbles}/{total_marbles-1} = {p_blue_second_given_red:.4f}")
print(f"P(Red then Blue)      = {p_red_then_blue:.4f}")
print(f"As a fraction         = {red_marbles*blue_marbles}/{total_marbles*(total_marbles-1)} = {red_marbles*blue_marbles}/90")

# === Combinatorics in Probability: At-Least-One and Multi-Event Problems ===

import math

def combinations(n, r):
    """nCr — number of ways to choose r items from n (order doesn't matter)"""
    return math.comb(n, r)   # Python 3.8+ has this built-in

# ---------------------------------------------------------------
# PROBLEM 1: "At Least One" — Use the Complement Trick
# ---------------------------------------------------------------
# Q: A bag has 4 red and 6 blue marbles. Draw 3 without replacement.
#    What's P(at least one red marble)?

total_marbles = 10
red = 4
blue = 6
draw = 3

# Total ways to draw 3 from 10
total_ways = combinations(total_marbles, draw)   # 10C3 = 120

# P(at least one red) = 1 - P(NO red at all)
# 'No red' means all 3 are blue — choose 3 from 6 blue marbles
all_blue_ways = combinations(blue, draw)          # 6C3 = 20

p_no_red = all_blue_ways / total_ways
p_at_least_one_red = 1 - p_no_red               # the complement shortcut

print("=== PROBLEM 1: At Least One Red ===")
print(f"Total ways to draw 3 from 10 : 10C3 = {total_ways}")
print(f"Ways to draw 3 all-blue      : 6C3  = {all_blue_ways}")
print(f"P(no red)                    = {all_blue_ways}/{total_ways} = {p_no_red:.4f}")
print(f"P(at least one red)          = 1 - {p_no_red:.4f} = {p_at_least_one_red:.4f}")

print()

# ---------------------------------------------------------------
# PROBLEM 2: Exactly K Successes — Combinations in Numerator
# ---------------------------------------------------------------
# Q: From a group of 7 men and 5 women, a committee of 4 is formed randomly.
#    What's P(exactly 2 men and 2 women on the committee)?

total_people = 12   # 7 men + 5 women
men = 7
women = 5
committee_size = 4

# Total ways to form a committee of 4 from 12 people
total_committees = combinations(total_people, committee_size)   # 12C4 = 495

# Favourable: choose exactly 2 men from 7 AND exactly 2 women from 5
# These are independent choices for the two sub-groups
ways_to_pick_2_men   = combinations(men, 2)     # 7C2 = 21
ways_to_pick_2_women = combinations(women, 2)   # 5C2 = 10
favourable_committees = ways_to_pick_2_men * ways_to_pick_2_women  # 210

p_exactly_2_and_2 = favourable_committees / total_committees
print("=== PROBLEM 2: Exactly 2 Men and 2 Women ===")
print(f"Total committee arrangements : 12C4 = {total_committees}")
print(f"Ways to pick 2 men from 7    : 7C2  = {ways_to_pick_2_men}")
print(f"Ways to pick 2 women from 5  : 5C2  = {ways_to_pick_2_women}")
print(f"Favourable arrangements      : {ways_to_pick_2_men} × {ways_to_pick_2_women} = {favourable_committees}")
print(f"P(exactly 2 men, 2 women)    = {favourable_committees}/{total_committees} = {p_exactly_2_and_2:.4f}")

print()

# ---------------------------------------------------------------
# PROBLEM 3: Independent Repeated Trials — Coin Flipped 5 Times
# ---------------------------------------------------------------
# Q: What's P(getting exactly 3 Heads in 5 fair coin flips)?
# This is a Binomial scenario: n=5 trials, k=3 successes, p=0.5

n_flips = 5
k_heads = 3
p_head = 0.5
p_tail = 1 - p_head

# Ways to arrange 3 heads in 5 flips: 5C3
arrangements = combinations(n_flips, k_heads)   # = 10
p_exactly_3_heads = arrangements * (p_head ** k_heads) * (p_tail ** (n_flips - k_heads))

print("=== PROBLEM 3: Exactly 3 Heads in 5 Flips ===")
print(f"Arrangements of 3H in 5 flips: 5C3 = {arrangements}")
print(f"P(H)^3 = {p_head}^3 = {p_head**k_heads}")
print(f"P(T)^2 = {p_tail}^2 = {p_tail**(n_flips-k_heads)}")
print(f"P(exactly 3 Heads) = {arrangements} × {p_head**k_heads} × {p_tail**2} = {p_exactly_3_heads:.4f}")

# === Bayes' Theorem: Medical Test Example ===
# A rare disease affects 1 in 10,000 people. The test correctly identifies the disease 99% of the time
# (true positive rate = 0.99). The test has a false positive rate of 1%.
# If a person tests positive, what is the probability they actually have the disease?

# Prior probability of having the disease
p_disease = 1 / 10000   # 0.0001
# Probability of testing positive given the disease (sensitivity)
p_pos_given_disease = 0.99
# Probability of testing positive given no disease (false positive rate)
p_pos_given_no_disease = 0.01
# Probability of not having the disease
p_no_disease = 1 - p_disease

# Total probability of testing positive: P(pos) = P(pos|disease)*P(disease) + P(pos|no disease)*P(no disease)
p_pos = (p_pos_given_disease * p_disease) + (p_pos_given_no_disease * p_no_disease)

# Bayes: P(disease|pos) = P(pos|disease)*P(disease) / P(pos)
p_disease_given_pos = (p_pos_given_disease * p_disease) / p_pos

print("=== Bayes' Theorem: Medical Test ===")
print(f"P(disease) = {p_disease:.6f} (1 in 10,000)")
print(f"P(pos|disease) = {p_pos_given_disease}")
print(f"P(pos|no disease) = {p_pos_given_no_disease}")
print(f"\nTotal probability of positive test: P(pos) = {p_pos:.6f}")
print(f"Probability of having the disease given a positive test: P(disease|pos) = {p_disease_given_pos:.4f}")
print(f"\n=> Only about {p_disease_given_pos*100:.1f}% — far lower than the 99% most people guess!")

# Sanity check: use simulation to verify
import random
random.seed(42)
simulations = 100_000
positive_tests = 0
actual_disease = 0
for _ in range(simulations):
    has_disease = random.random() < p_disease
    if has_disease:
        test_positive = random.random() < p_pos_given_disease
    else:
        test_positive = random.random() < p_pos_given_no_disease
    if test_positive:
        positive_tests += 1
        if has_disease:
            actual_disease += 1

print(f"\nSimulation: {positive_tests} positive tests out of {simulations}")
print(f"Of those, {actual_disease} actually had the disease: {actual_disease/positive_tests:.4f}")

# === Expected Value: Decision Making Under Uncertainty ===

def expected_value(outcomes, probabilities):
    """
    outcomes: list of numerical values (e.g., winnings)
    probabilities: list of probabilities (must sum to 1)
    """
    if abs(sum(probabilities) - 1) > 1e-10:
        raise ValueError("Probabilities must sum to 1.")
    ev = sum(v * p for v, p in zip(outcomes, probabilities))
    return ev

# --- Game 1: Die roll ---
# Roll a fair die. If 6: win $10. Otherwise: lose $2.
outcomes = [10, -2]
probabilities = [1/6, 5/6]
ev1 = expected_value(outcomes, probabilities)
print("=== Game 1: Roll a Die ===")
print(f"Outcomes: win $10 (P=1/6), lose $2 (P=5/6)")
print(f"Expected Value = ${ev1:.2f}")
print("(Fair game — expected value is zero)")

print()

# --- Game 2: Raffle ticket ---
# 1000 tickets sold at $5 each. Prizes: 1 grand prize of $1000, 5 consolation prizes of $100.
# What is the expected value of buying one ticket?
ticket_price = 5
prizes = [(1000, 1), (100, 5)]
total_tickets = 1000

# Compute expected payout
payout_ev = sum(prize * count / total_tickets for prize, count in prizes)
# Net expected value: payout minus cost
net_ev = payout_ev - ticket_price
print("=== Game 2: Raffle Ticket ===")
print(f"Ticket price: ${ticket_price}")
print(f"Payout EV: ${payout_ev:.2f}")
print(f"Net EV (including cost): ${net_ev:.2f}")
print("(Negative EV — not a good investment unless you enjoy the cause)")

print()

# --- Game 3: Decision tree with two choices ---
# Choice A: Invest $100 in a 60% chance of $200 return, 40% chance of $50 return.
# Choice B: Keep the $100 (sure thing).
# Which has higher expected value?
choice_a_outcomes = [200, 50]  # returns, not net
choice_a_probs = [0.6, 0.4]
ev_a = expected_value(choice_a_outcomes, choice_a_probs) - 100  # subtract investment
ev_b = 100 - 100  # keep it: net = 0
print("=== Game 3: Decision Tree ===")
print(f"Choice A: Invest $100 -> EV = ${ev_a:.2f}")
print(f"Choice B: Keep $100 -> EV = ${ev_b:.2f}")
if ev_a > ev_b:
    print("Decision: Invest (higher EV)")
else:
    print("Decision: Keep (lower risk, higher EV)")

// io.thecodeforge — interview tutorial

import random

def simulate_dice_rolls(num_dice: int, trials: int = 100_000) -> float:
    """
    Monte Carlo validation — used only to confirm the math,
    not because we're too lazy to think.
    """
    successes = 0
    for _ in range(trials):
        total = sum(random.randint(1, 6) for _ in range(num_dice))
        if total % 6 == 0:
            successes += 1
    return successes / trials

if __name__ == "__main__":
    for n in [1, 2, 5, 10]:
        prob = simulate_dice_rolls(n)
        print(f"N={n:2d}  p(sum%6==0) = {prob:.4f}  (expected 0.1667)")

// io.thecodeforge — interview tutorial

import random
from math import comb

def exact_probability(n: int, threshold: float, upper_bound: float) -> float:
    """P(median of n > threshold) for Uniform(0, upper_bound)."""
    p = (upper_bound - threshold) / upper_bound
    k = n // 2 + 1  # need at least this many above threshold
    prob = 0.0
    for i in range(k, n + 1):
        prob += comb(n, i) * (p ** i) * ((1 - p) ** (n - i))
    return prob

if __name__ == "__main__":
    n, threshold, bound = 3, 1.5, 2.0
    exact = exact_probability(n, threshold, bound)
    print(f"Exact binomial: {exact:.6f}")

    # Quick sanity: Monte Carlo
    trials = 1_000_000
    count = 0
    for _ in range(trials):
        draws = [random.uniform(0, bound) for _ in range(n)]
        draws.sort()
        if draws[n // 2] > threshold:
            count += 1
    print(f"Monte Carlo:    {count / trials:.6f}")

def bayes_disease():
    # Prior: P(D) = 0.01
    p_d = 0.01
    # Likelihood: P(positive|D) = 0.99
    p_pos_given_d = 0.99
    # Marginal: P(positive) = P(positive|D)*P(D) + P(positive|~D)*P(~D)
    p_pos = p_pos_given_d * p_d + 0.01 * (1 - p_d)
    # Posterior: P(D|positive)
    p_d_given_pos = (p_pos_given_d * p_d) / p_pos
    return p_d_given_pos

print(bayes_disease())  # Output: 0.5

import math

def full_house_probability():
    total_hands = math.comb(52, 5)
    # Choose rank for three: 13, choose 3 suits: C(4,3)=4
    # Choose rank for pair: 12, choose 2 suits: C(4,2)=6
    favorable = 13 * math.comb(4,3) * 12 * math.comb(4,2)
    return favorable / total_hands

print(full_house_probability())  # Output: 0.0014405762304921968

def expected_value():
    # Game: cost $5, win $20 on 6, lose otherwise
    outcomes = [(1/6, 20), (5/6, 0)]
    ev = sum(p * v for p, v in outcomes) - 5
    return ev

print(expected_value())  # Output: -1.6666666666666667