Print Zero Even Odd

Print Zero Even Odd - Problem

Concurrency Medium

You have a function printNumber that can be called with an integer parameter and prints it to the console. For example, calling printNumber(7) prints 7 to the console.

You are given an instance of the class ZeroEvenOdd that has three functions: zero, even, and odd. The same instance of ZeroEvenOdd will be passed to three different threads:

Thread A: calls zero() that should only output 0's.
Thread B: calls even() that should only output even numbers.
Thread C: calls odd() that should only output odd numbers.

Modify the given class to output the series "010203040506..." where the length of the series must be 2n.

Implement the ZeroEvenOdd class:

ZeroEvenOdd(int n) Initializes the object with the number n that represents the numbers that should be printed.
void zero(printNumber) Calls printNumber to output one zero.
void even(printNumber) Calls printNumber to output one even number.
void odd(printNumber) Calls printNumber to output one odd number.

Input & Output

Example 1 — Basic Case

$ Input: n = 2

› Output: 0102

💡 Note: Zero thread prints 0, odd thread prints 1, zero thread prints 0, even thread prints 2. Pattern: 0→1→0→2

Example 2 — Larger Sequence

$ Input: n = 5

› Output: 0102030405

💡 Note: Complete sequence: 0→1→0→2→0→3→0→4→0→5. Total length is 2×5=10 characters.

Example 3 — Edge Case

$ Input: n = 1

› Output: 01

💡 Note: Minimum case: zero prints 0, odd prints 1. Length is 2×1=2.

Constraints

1 ≤ n ≤ 1000

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 20 a Amazon 15 f Facebook 12

The key insight is coordinating three threads to print in alternating pattern: zero-odd-zero-even-zero-odd... Best approach uses semaphores to eliminate busy waiting and provide clean synchronization. Time: O(n), Space: O(1)

Common Approaches

✓ Busy Waiting with Shared Flag

⏱️ Time: O(n) Space: O(1)

Each thread continuously checks a shared counter to determine when it's their turn to execute. The counter cycles through states: 0 for zero thread, 1 for odd thread, 2 for even thread.

Semaphore-Based Synchronization

⏱️ Time: O(n) Space: O(1)

Each thread uses semaphores to wait for their turn and signal the next thread. This eliminates busy waiting and provides better performance through proper thread synchronization.

Busy Waiting with Shared Flag — Algorithm Steps

Step 1: Initialize shared counter to 0
Step 2: Each thread busy waits until counter matches their state
Step 3: Print number and update counter to next state

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set state=0, currentNum=1

Coordinate

Threads check state and wait for their turn

Execute

Print number and update state for next thread

Code -

solution.c — C

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

char* solution(int n) {
    // Max digits: n zeros + numbers 1 to n, each up to a few digits
    char* result = malloc(1000);
    result[0] = '\0';
    char buf[10];

    for (int i = 1; i <= n; i++) {
        strcat(result, "0");
        sprintf(buf, "%d", i);
        strcat(result, buf);
    }

    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    char* result = solution(n);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each thread executes n times with constant work per execution

✓ Linear Growth

Space Complexity

O(1)

Only uses a single shared counter variable

✓ Linear Space

32.0K Views

Medium Frequency

~25 min Avg. Time

890 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

Busy Waiting with Shared Flag — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler