Fizz Buzz Multithreaded - Practice Coding Problems

Fizz Buzz Multithreaded - Problem

Concurrency Medium

Welcome to the world of multithreaded programming! This problem combines the classic FizzBuzz game with concurrent execution, creating a fascinating challenge in thread synchronization.

You're given a FizzBuzz class that needs to coordinate four different threads to produce the correct output sequence. Each thread has a specific responsibility:

Thread A: Calls fizz() to print "fizz" when numbers are divisible by 3 but not 5
Thread B: Calls buzz() to print "buzz" when numbers are divisible by 5 but not 3
Thread C: Calls fizzbuzz() to print "fizzbuzz" when numbers are divisible by both 3 and 5
Thread D: Calls number() to print the actual number when it's not divisible by 3 or 5

The challenge is to synchronize these threads so they output the sequence [1, 2, "fizz", 4, "buzz", "fizz", 7, 8, "fizz", "buzz", 11, "fizz", 13, 14, "fizzbuzz", ...] in the correct order, despite running concurrently.

Goal: Implement thread synchronization mechanisms to ensure the output appears in sequential order from 1 to n.

Input & Output

example_1.py — Basic Case

$ Input: n = 15

› Output: 1,2,fizz,4,buzz,fizz,7,8,fizz,buzz,11,fizz,13,14,fizzbuzz

💡 Note: For n=15, the sequence includes all FizzBuzz rules. Numbers 1,2,4,7,8,11,13,14 are printed as-is, multiples of 3 (but not 5) become 'fizz', multiples of 5 (but not 3) become 'buzz', and multiples of both become 'fizzbuzz'.

example_2.py — Small Case

$ Input: n = 5

› Output: 1,2,fizz,4,buzz

💡 Note: For n=5, we get: 1 (not divisible), 2 (not divisible), 3 (divisible by 3 only → fizz), 4 (not divisible), 5 (divisible by 5 only → buzz).

example_3.py — Edge Case

$ Input: n = 1

› Output: 1

💡 Note: For n=1, only the number 1 is in range. Since 1 is not divisible by 3 or 5, it's printed as-is by the number thread.

Visualization

Tap to expand

Understanding the Visualization

Orchestra Assembly

Four musicians (threads) take their positions: Fizz violinist, Buzz trumpeter, FizzBuzz pianist, and Number drummer. Each knows exactly when to play.

Conductor's Baton

The shared counter acts as the conductor's baton, indicating which beat (number) we're currently on. All musicians watch the conductor.

Wait for Cue

Musicians wait silently (condition variable wait) until the conductor signals it's their turn. No energy wasted on constant checking.

Perfect Harmony

When it's their turn, the appropriate musician plays their note, the conductor moves to the next beat, and wakes everyone for the next cue.

Key Takeaway

🎯 Key Insight: Use condition variables to make threads wait efficiently without consuming CPU cycles, then wake them up only when the shared state changes - creating perfect synchronization like a well-conducted orchestra!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each number is processed exactly once with efficient waiting

✓ Linear Growth

Space Complexity

O(1)

Uses only synchronization primitives and a counter

✓ Linear Space

Constraints

1 ≤ n ≤ 50
Four threads will be created to call the four functions concurrently
The same instance of FizzBuzz will be passed to all four threads
Thread safety is required - output must be in correct sequential order

Asked in

a Amazon 35 ⊞ Microsoft 28 G Google 22 f Meta 18

The optimal solution uses condition variables with mutex locks to coordinate four threads efficiently. Each thread waits on a condition variable until it's their turn to act, eliminating CPU waste from busy waiting. When a thread's condition is met (divisibility rules), it prints the appropriate output, increments the shared counter, and signals all other threads to wake up and check the new state. This approach ensures perfect sequential ordering while maintaining high performance through efficient thread synchronization.

Common Approaches

Approach	Time	Space	Notes
✓ Busy Waiting with Simple Flag	O(n)	O(1)	Use a simple shared counter with busy waiting for thread coordination
Condition Variables (Optimal)	O(n)	O(1)	Use condition variables and mutex for efficient thread synchronization without busy waiting

Busy Waiting with Simple Flag — Algorithm Steps

Initialize a shared counter starting at 1
Each thread continuously checks if current number matches their condition
When a match is found, the thread processes and prints its output
Increment counter and repeat until reaching n
Use basic locks to prevent race conditions on the counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

All 4 threads start and begin checking the shared counter

Check Condition

Each thread checks if current number matches their responsibility

Act or Wait

Matching thread acts and increments counter, others continue waiting

Repeat

Process continues until counter exceeds n

Code -

solution.c — C

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

typedef struct {
    int n;
    int current;
    pthread_mutex_t mutex;
} FizzBuzz;

FizzBuzz* createFizzBuzz(int n) {
    FizzBuzz* fb = malloc(sizeof(FizzBuzz));
    fb->n = n;
    fb->current = 1;
    pthread_mutex_init(&fb->mutex, NULL);
    return fb;
}

void fizz(FizzBuzz* obj, void (*printFizz)()) {
    while (1) {
        pthread_mutex_lock(&obj->mutex);
        if (obj->current > obj->n) {
            pthread_mutex_unlock(&obj->mutex);
            break;
        }
        if (obj->current % 3 == 0 && obj->current % 5 != 0) {
            printFizz();
            obj->current++;
        }
        pthread_mutex_unlock(&obj->mutex);
        usleep(1000); // Prevent busy waiting
    }
}

void buzz(FizzBuzz* obj, void (*printBuzz)()) {
    while (1) {
        pthread_mutex_lock(&obj->mutex);
        if (obj->current > obj->n) {
            pthread_mutex_unlock(&obj->mutex);
            break;
        }
        if (obj->current % 5 == 0 && obj->current % 3 != 0) {
            printBuzz();
            obj->current++;
        }
        pthread_mutex_unlock(&obj->mutex);
        usleep(1000);
    }
}

void fizzbuzz(FizzBuzz* obj, void (*printFizzBuzz)()) {
    while (1) {
        pthread_mutex_lock(&obj->mutex);
        if (obj->current > obj->n) {
            pthread_mutex_unlock(&obj->mutex);
            break;
        }
        if (obj->current % 3 == 0 && obj->current % 5 == 0) {
            printFizzBuzz();
            obj->current++;
        }
        pthread_mutex_unlock(&obj->mutex);
        usleep(1000);
    }
}

void number(FizzBuzz* obj, void (*printNumber)(int)) {
    while (1) {
        pthread_mutex_lock(&obj->mutex);
        if (obj->current > obj->n) {
            pthread_mutex_unlock(&obj->mutex);
            break;
        }
        if (obj->current % 3 != 0 && obj->current % 5 != 0) {
            printNumber(obj->current);
            obj->current++;
        }
        pthread_mutex_unlock(&obj->mutex);
        usleep(1000);
    }
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each number from 1 to n is processed exactly once, but with inefficient waiting

✓ Linear Growth

Space Complexity

O(1)

Only uses a shared counter and basic synchronization primitives

✓ Linear Space

Constraints

1 ≤ n ≤ 50
Four threads will be created to call the four functions concurrently
The same instance of FizzBuzz will be passed to all four threads
Thread safety is required - output must be in correct sequential order

42.8K Views

Medium Frequency

~25 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

Busy Waiting with Simple Flag — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler