Codestin Search App

Building H2O - Problem

Concurrency Medium

Imagine a molecular assembly line where oxygen and hydrogen threads arrive randomly, but they must form water molecules (H₂O) in perfect groups of three: exactly 2 hydrogen + 1 oxygen.

Your challenge is to implement a synchronization barrier that ensures threads pass through in complete molecular sets. No thread can proceed alone - they must wait for their molecular partners!

The Rules:

🧪 Perfect Molecules: Every group of 3 threads must contain exactly 2 hydrogen and 1 oxygen
⏳ Patient Waiting: If an oxygen thread arrives but there aren't 2 hydrogen threads ready, it must wait
🔄 Complete Bonding: All 3 threads from one molecule must bond completely before any threads from the next molecule start
🎯 Atomic Groups: Threads pass the barrier in indivisible groups of three

You'll implement two methods: hydrogen() and oxygen() that handle the synchronization logic. Each method calls releaseHydrogen() or releaseOxygen() respectively when it's safe to proceed.

Input & Output

example_1.py — Basic Molecule Formation

$ Input: Thread sequence: "OOHHHH"

› Output: Possible output: "HHOHHO" or "HOHHOH"

💡 Note: 6 threads arrive (2 oxygen, 4 hydrogen). They form 2 complete H₂O molecules. The exact order within each molecule group may vary, but we get exactly 2 complete molecules.

example_2.py — Perfect Balance

$ Input: Thread sequence: "HHOHHO"

› Output: Possible output: "HHOHHO" or "HOHHOH"

💡 Note: Perfect input with exactly 2 molecules worth of threads. All threads can proceed immediately once their molecular partners arrive.

example_3.py — Excess Hydrogen

$ Input: Thread sequence: "HHHHHHO"

› Output: Output: "HHO" (3 threads released, 4 threads wait)

💡 Note: Only 1 complete molecule can be formed. 2 hydrogen threads and 1 oxygen thread are released, while 4 hydrogen threads remain waiting for more oxygen threads.

Constraints

1 ≤ total threads ≤ 1000
Each thread is either hydrogen ('H') or oxygen ('O')
Threads may arrive in any order
Must guarantee atomic molecule formation
Solution must be thread-safe and deadlock-free

Visualization

Tap to expand

Understanding the Visualization

Atoms Arrive

Hydrogen and oxygen atoms arrive randomly at the assembly line

Waiting Areas

Atoms wait in designated areas - hydrogen area (max 2), oxygen area (max 1)

Molecule Formation

When 2H + 1O are ready, they form a complete H₂O molecule

Synchronized Release

All 3 atoms in the molecule are released together atomically

Key Takeaway

🎯 Key Insight: Semaphores act as intelligent waiting rooms that automatically coordinate the perfect 2:1 hydrogen-to-oxygen ratio, while barriers ensure atomic molecule release - no busy waiting, no waste!

Asked in

G Google 45 ⊞ Microsoft 38 a Amazon 32 f Meta 28

The optimal solution uses semaphores to elegantly coordinate thread synchronization. A hydrogen semaphore (capacity 2) and oxygen semaphore (capacity 1) ensure proper ratios, while a barrier guarantees atomic molecule formation. This eliminates busy waiting and provides O(1) time complexity per thread with perfect synchronization.

Common Approaches

Approach	Time	Space	Notes
✓ Naive Busy Waiting	O(n)	O(1)	Use simple counters with busy waiting loops
Semaphore-Based Synchronization (Optimal)	O(1)	O(1)	Use semaphores and barriers for efficient thread coordination

Naive Busy Waiting — Algorithm Steps

Maintain simple counters for hydrogen and oxygen threads
Use busy waiting loops to check for molecule completion
Basic mutex for counter updates
High CPU usage due to continuous polling

Visualization

Tap to expand

Step-by-Step Walkthrough

Thread Arrival

Threads arrive and check counters

Busy Waiting

Threads spin in loops checking conditions

CPU Waste

High CPU usage from continuous polling

Code -

solution.c — C

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

typedef struct {
    int hCount;
    int oCount;
    pthread_mutex_t mutex;
} H2O;

void hydrogen(H2O* h2o, void (*releaseHydrogen)()) {
    while (1) {
        pthread_mutex_lock(&h2o->mutex);
        if (h2o->hCount < 2) {
            h2o->hCount++;
            releaseHydrogen();
            if (h2o->hCount == 2 && h2o->oCount == 1) {
                h2o->hCount = 0;
                h2o->oCount = 0;
            }
            pthread_mutex_unlock(&h2o->mutex);
            return;
        }
        pthread_mutex_unlock(&h2o->mutex);
        usleep(1000);
    }
}

void oxygen(H2O* h2o, void (*releaseOxygen)()) {
    while (1) {
        pthread_mutex_lock(&h2o->mutex);
        if (h2o->oCount == 0) {
            h2o->oCount = 1;
            releaseOxygen();
            if (h2o->hCount == 2) {
                h2o->hCount = 0;
                h2o->oCount = 0;
            }
            pthread_mutex_unlock(&h2o->mutex);
            return;
        }
        pthread_mutex_unlock(&h2o->mutex);
        usleep(1000);
    }
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each thread may spin-wait, leading to wasted CPU cycles

✓ Linear Growth

Space Complexity

O(1)

Only basic counters needed

✓ Linear Space

78.3K Views

High Frequency

~25 min Avg. Time

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

Naive Busy Waiting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler