Soup Servings - Practice Coding Problems

Soup Servings - Problem

Soup Servings is a fascinating probability problem that simulates a random serving process.

You have two soups, A and B, each starting with n mL. On every turn, one of four serving operations is chosen randomly with equal probability (0.25 each):

🥄 Operation 1: Pour 100 mL from A, 0 mL from B
🥄 Operation 2: Pour 75 mL from A, 25 mL from B
🥄 Operation 3: Pour 50 mL from A, 50 mL from B
🥄 Operation 4: Pour 25 mL from A, 75 mL from B

Notice: There's no operation that pours 0 mL from A and 100 mL from B, making soup A more likely to run out first!

If an operation asks to pour more than what remains, pour all that's left. The process stops when at least one soup runs out.

Goal: Return the probability that A runs out before B, plus half the probability that both soups run out simultaneously.

Input & Output

example_1.py — Small Input

$ Input: n = 50

› Output: 0.62500

💡 Note: With 50mL each, there are limited possible states. The biased operations make soup A more likely to empty first, resulting in probability ≈ 0.625

example_2.py — Medium Input

$ Input: n = 100

› Output: 0.71875

💡 Note: With 100mL each, the probability increases as the bias toward emptying soup A becomes more pronounced over more operations

example_3.py — Large Input

$ Input: n = 5000

› Output: 1.00000

💡 Note: For large values, the mathematical optimization kicks in. The probability approaches 1.0 due to the heavily biased operations

Visualization

Tap to expand

Understanding the Visualization

Initial State

Both soup pots A and B start with n mL

Random Operations

One of 4 operations chosen randomly (notice A-bias)

State Transitions

Each operation leads to a new state with reduced amounts

Probability Calculation

Compute probability A empties first + 0.5×(both empty together)

Key Takeaway

🎯 Key Insight: The operations are biased toward emptying soup A faster (average 62.5mL vs 37.5mL per turn), making the probability approach 1.0 for large inputs!

Time & Space Complexity

Time Complexity

⏱️

O(n²)

At most n²/625 unique states (scaled down by 25), each computed once

⚠ Quadratic Growth

Space Complexity

O(n²)

Memoization table stores up to n²/625 states plus recursion stack

⚠ Quadratic Space

Constraints

0 ≤ n ≤ 10⁹
Answers within 10^-5 of the actual answer will be accepted
All operations pour multiples of 25mL

Asked in

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

The optimal solution uses memoized dynamic programming with mathematical optimization. Key insights: scale down by 25 to reduce state space, use memoization to avoid recalculating states, and return 1.0 for large inputs where probability approaches certainty due to biased operations.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Simulation	O(4^(n/25))	O(n/25)	Recursively simulate all possible serving sequences without memoization
Memoized Dynamic Programming (Optimal)	O(n²)	O(n²)	Use memoization to cache results and mathematical optimization for large values

Recursive Simulation — Algorithm Steps

Base case: if A is empty, return 1.0 (A finished first or tied)
Base case: if B is empty but A isn't, return 0.0 (B finished first)
For each of the 4 operations, recursively calculate probability
Return average of all 4 operation probabilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Start State

Begin with (n, n) soup amounts

Branch Operations

Try all 4 operations from current state

Recurse

Recursively solve each resulting state

Average Results

Return weighted average of all branches

Code -

solution.c — C

#include <stdio.h>

double solve(int a, int b) {
    if (a <= 0 && b <= 0) return 0.5;
    if (a <= 0) return 1.0;
    if (b <= 0) return 0.0;
    
    double prob = 0.0;
    prob += solve(a - 100, b);
    prob += solve(a - 75, b - 25);
    prob += solve(a - 50, b - 50);
    prob += solve(a - 25, b - 75);
    
    return prob * 0.25;
}

double soupServings(int n) {
    return solve(n, n);
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%.5f\n", soupServings(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^(n/25))

Each recursive call branches into 4 more calls, depth roughly n/25

✓ Linear Growth

Space Complexity

O(n/25)

Maximum recursion depth is approximately n/25

⚡ Linearithmic Space

Constraints

0 ≤ n ≤ 10⁹
Answers within 10^-5 of the actual answer will be accepted
All operations pour multiples of 25mL

28.5K Views

Medium Frequency

~25 min Avg. Time

845 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

Recursive Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler