Fizz Buzz Multithreaded - Practice Coding Problems

Fizz Buzz Multithreaded - Problem

Concurrency Medium

You have four functions: printFizz that prints "fizz", printBuzz that prints "buzz", printFizzBuzz that prints "fizzbuzz", and printNumber that prints a given integer.

You are given an instance of the class FizzBuzz that has four functions: fizz, buzz, fizzbuzz and number. The same instance will be passed to four different threads:

Thread A: calls fizz() that should output "fizz"
Thread B: calls buzz() that should output "buzz"
Thread C: calls fizzbuzz() that should output "fizzbuzz"
Thread D: calls number() that should output integers

Modify the given class to output the series [1, 2, "fizz", 4, "buzz", ...] where the i-th token (1-indexed) is:

"fizzbuzz" if i is divisible by 3 and 5
"fizz" if i is divisible by 3 and not 5
"buzz" if i is divisible by 5 and not 3
i if i is not divisible by 3 or 5

Input & Output

Example 1 — Basic Case

$ Input: n = 15

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

💡 Note: For each number 1 to 15: 1,2 → numbers; 3,6,9,12 → fizz; 5,10 → buzz; 15 → fizzbuzz

Example 2 — Small Range

$ Input: n = 5

› Output: ["1", "2", "fizz", "4", "buzz"]

💡 Note: 1,2,4 are regular numbers; 3 is divisible by 3 only → fizz; 5 is divisible by 5 only → buzz

Example 3 — Include FizzBuzz

$ Input: n = 30

› Output: ["1", "2", "fizz", "4", "buzz", "fizz", "7", "8", "fizz", "buzz", "11", "fizz", "13", "14", "fizzbuzz", "16", "17", "fizz", "19", "buzz", "fizz", "22", "23", "fizz", "buzz", "26", "fizz", "28", "29", "fizzbuzz"]

💡 Note: Numbers 15 and 30 are divisible by both 3 and 5, so they become fizzbuzz

Constraints

1 ≤ n ≤ 50

Visualization

Tap to expand

Understanding the Visualization

Input

n = 15 (generate sequence from 1 to 15)

Thread Coordination

Four threads check conditions and execute in order

Output

Sequential FizzBuzz sequence with proper synchronization

Key Takeaway

🎯 Key Insight: Thread synchronization ensures correct sequential output despite concurrent execution

Asked in

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

The key insight is using thread synchronization to coordinate four concurrent threads that must produce output in sequential order. Best approach uses condition variables to avoid busy waiting while maintaining correct sequence. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Condition Variable Synchronization	O(n)	O(1)	Use condition variables to efficiently coordinate threads without busy waiting
Simple Lock-based Synchronization	O(n)	O(1)	Use a shared counter with locks to coordinate thread execution

Condition Variable Synchronization — Algorithm Steps

Step 1: Initialize shared state with condition variables
Step 2: Threads wait on condition variables until their turn
Step 3: Signal next appropriate thread after execution

Visualization

Tap to expand

Step-by-Step Walkthrough

Wait State

Threads sleep until condition is met

Signal

Active thread signals all waiting threads

Check & Continue

Awakened threads check condition and continue

Code -

solution.c — C

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

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

void* fizzThread(void* arg) {
    FizzBuzz* fb = (FizzBuzz*)arg;
    
    pthread_mutex_lock(&fb->mutex);
    while (fb->current <= fb->n) {
        if (fb->current % 3 == 0 && fb->current % 5 != 0) {
            printf("fizz\n");
            fb->current++;
            pthread_cond_broadcast(&fb->cond);
        } else {
            pthread_cond_wait(&fb->cond, &fb->mutex);
        }
    }
    pthread_mutex_unlock(&fb->mutex);
    
    return NULL;
}

void* buzzThread(void* arg) {
    FizzBuzz* fb = (FizzBuzz*)arg;
    
    pthread_mutex_lock(&fb->mutex);
    while (fb->current <= fb->n) {
        if (fb->current % 5 == 0 && fb->current % 3 != 0) {
            printf("buzz\n");
            fb->current++;
            pthread_cond_broadcast(&fb->cond);
        } else {
            pthread_cond_wait(&fb->cond, &fb->mutex);
        }
    }
    pthread_mutex_unlock(&fb->mutex);
    
    return NULL;
}

char** solution(int n) {
    char** result = (char**)malloc(n * sizeof(char*));
    
    for (int i = 1; i <= n; i++) {
        result[i-1] = (char*)malloc(20 * sizeof(char));
        if (i % 15 == 0) {
            strcpy(result[i-1], "fizzbuzz");
        } else if (i % 3 == 0) {
            strcpy(result[i-1], "fizz");
        } else if (i % 5 == 0) {
            strcpy(result[i-1], "buzz");
        } else {
            sprintf(result[i-1], "%d", i);
        }
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each number from 1 to n is processed exactly once

✓ Linear Growth

Space Complexity

O(1)

Uses fixed amount of synchronization variables

✓ Linear Space

28.0K Views

Medium Frequency

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

Condition Variable Synchronization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler