Print Zero Even Odd - Practice Coding Problems

Print Zero Even Odd - Problem

Concurrency Medium

Imagine you're conducting a synchronized orchestra of threads! 🎼

You have a function printNumber that prints integers to the console. Your task is to implement a ZeroEvenOdd class that coordinates three different threads to produce a specific pattern.

The Challenge: Three threads must work together:

Thread A: Calls zero() - outputs only zeros
Thread B: Calls even() - outputs only even numbers
Thread C: Calls odd() - outputs only odd numbers

The threads must coordinate to produce the sequence: "010203040506..."

Pattern Breakdown: For n=3, output should be 010203 (length 2n=6)
- Position 1,3,5: zeros (0)
- Position 2: odd number (1)
- Position 4: even number (2)
- Position 6: odd number (3)

Key Challenge: Ensure proper synchronization so threads don't interfere with each other!

Input & Output

example_1.py — Basic Case

$ Input: n = 2

› Output: 0102

💡 Note: For n=2, we need to print numbers 1,2. Pattern: zero(0) → odd(1) → zero(0) → even(2). Total length = 4 = 2*n.

example_2.py — Medium Case

$ Input: n = 5

› Output: 0102030405

💡 Note: For n=5, pattern alternates: 0-1-0-2-0-3-0-4-0-5. Zero appears before each number from 1 to 5. Total length = 10 = 2*n.

example_3.py — Single Number

$ Input: n = 1

› Output: 01

💡 Note: Edge case: Only number 1 to print. Pattern: zero(0) → odd(1). Total length = 2 = 2*n.

Visualization

Tap to expand

Understanding the Visualization

Setup Phase

Zero thread gets the conductor's baton (semaphore permit), others wait

Zero Plays

Zero thread prints '0', then passes baton to odd or even thread

Number Plays

Odd/even thread prints their number, passes baton back to zero

Perfect Rhythm

Pattern continues: 0-1-0-2-0-3... with perfect synchronization

Key Takeaway

🎯 Key Insight: Semaphores provide the perfect synchronization mechanism - like a conductor's baton that ensures each thread performs exactly when needed, with zero CPU waste and guaranteed correctness.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each number is printed exactly once, with efficient waiting

✓ Linear Growth

Space Complexity

O(1)

Only using semaphores and basic counters

✓ Linear Space

Constraints

1 ≤ n ≤ 1000
Three different threads will call zero(), even(), and odd() methods
Output must be exactly 2n characters long
Pattern must strictly alternate: 0 → number → 0 → number → ...

Asked in

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

The optimal approach uses semaphores for thread synchronization. Initialize zero semaphore with 1 permit, others with 0. Zero thread prints 0 and signals the appropriate odd/even thread, which then prints their number and signals back to zero. This creates perfect alternation: 0→1→0→2→0→3... with zero CPU waste and guaranteed correctness.

Common Approaches

Approach	Time	Space	Notes
✓ Semaphore Synchronization (Optimal)	O(n)	O(1)	Use semaphores and condition variables for efficient thread coordination
Brute Force (Busy Waiting)	O(n)	O(1)	Use simple flags and busy waiting loops to coordinate threads

Semaphore Synchronization (Optimal) — Algorithm Steps

Initialize semaphores: zero semaphore starts with permit, others blocked
Zero thread: wait on zero semaphore, print 0, signal appropriate thread
Odd/Even threads: wait on their semaphore, print number, signal zero
Continue pattern until all numbers printed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Zero semaphore has 1 permit, others blocked with 0 permits

Zero Acquires

Zero thread acquires permit, prints 0, signals next thread

Odd/Even Waits

Odd or even thread gets permit, prints number, signals zero

Efficient Cycle

No CPU waste - threads sleep until signaled

Code -

solution.c — C

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

typedef struct {
    int n;
    sem_t zeroSem;
    sem_t oddSem;
    sem_t evenSem;
    volatile int current;
} ZeroEvenOdd;

ZeroEvenOdd* createZeroEvenOdd(int n) {
    ZeroEvenOdd* obj = malloc(sizeof(ZeroEvenOdd));
    obj->n = n;
    obj->current = 1;
    sem_init(&obj->zeroSem, 0, 1);  // Start with zero
    sem_init(&obj->oddSem, 0, 0);   // Block initially
    sem_init(&obj->evenSem, 0, 0);  // Block initially
    return obj;
}

void destroyZeroEvenOdd(ZeroEvenOdd* obj) {
    sem_destroy(&obj->zeroSem);
    sem_destroy(&obj->oddSem);
    sem_destroy(&obj->evenSem);
    free(obj);
}

void zero(ZeroEvenOdd* obj, void (*printNumber)(int)) {
    for (int i = 0; i < obj->n; i++) {
        sem_wait(&obj->zeroSem);  // Wait for permission
        printNumber(0);
        
        // Decide which thread to signal next
        if (obj->current % 2 == 1) {
            sem_post(&obj->oddSem);   // Signal odd thread
        } else {
            sem_post(&obj->evenSem);  // Signal even thread
        }
    }
}

void odd(ZeroEvenOdd* obj, void (*printNumber)(int)) {
    for (int i = 1; i <= obj->n; i += 2) {  // Only odd numbers
        sem_wait(&obj->oddSem);  // Wait for permission
        printNumber(i);
        obj->current = i + 1;
        sem_post(&obj->zeroSem);  // Signal zero thread
    }
}

void even(ZeroEvenOdd* obj, void (*printNumber)(int)) {
    for (int i = 2; i <= obj->n; i += 2) {  // Only even numbers
        sem_wait(&obj->evenSem);  // Wait for permission
        printNumber(i);
        obj->current = i + 1;
        sem_post(&obj->zeroSem);  // Signal zero thread
    }
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each number is printed exactly once, with efficient waiting

✓ Linear Growth

Space Complexity

O(1)

Only using semaphores and basic counters

✓ Linear Space

Constraints

1 ≤ n ≤ 1000
Three different threads will call zero(), even(), and odd() methods
Output must be exactly 2n characters long
Pattern must strictly alternate: 0 → number → 0 → number → ...

58.2K Views

Medium Frequency

~18 min Avg. Time

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

Semaphore Synchronization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler