Fizz Buzz Multithreaded

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

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

✓ Condition Variable Synchronization

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

Instead of busy waiting, threads sleep until their condition is met using condition variables. This reduces CPU usage while maintaining correct synchronization.

Simple Lock-based Synchronization

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

Each thread continuously checks if it's their turn using a shared counter protected by locks. Threads busy-wait until their condition is met, then execute and increment the counter.

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>

#define MAX_SUMS 10000

int compare(const void *a, const void *b) {
    return (*(int*)b - *(int*)a);
}

int* solution(int** grid, int gridSize, int* gridColSize, int* returnSize) {
    if (gridSize == 0 || gridColSize[0] == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    int m = gridSize, n = gridColSize[0];
    int sums[MAX_SUMS];
    int sumCount = 0;
    
    // For each possible center
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            // Calculate maximum radius from this center
            int maxR = i;
            if (j < maxR) maxR = j;
            if (m-1-i < maxR) maxR = m-1-i;
            if (n-1-j < maxR) maxR = n-1-j;
            
            for (int r = 0; r <= maxR; r++) {
                if (r == 0) {
                    // Single cell rhombus
                    sums[sumCount++] = grid[i][j];
                } else {
                    // Calculate rhombus sum for radius r
                    int total = 0;
                    // Add all four vertices
                    total += grid[i-r][j];   // top
                    total += grid[i][j+r];   // right
                    total += grid[i+r][j];   // bottom
                    total += grid[i][j-r];   // left
                    
                    // Add edges (excluding vertices to avoid double counting)
                    for (int k = 1; k < r; k++) {
                        total += grid[i-r+k][j+k];   // top-right edge
                        total += grid[i+k][j+r-k];   // bottom-right edge
                        total += grid[i+r-k][j-k];   // bottom-left edge
                        total += grid[i-k][j-r+k];   // top-left edge
                    }
                    
                    sums[sumCount++] = total;
                }
            }
        }
    }
    
    // Remove duplicates and sort
    qsort(sums, sumCount, sizeof(int), compare);
    
    int* result = (int*)malloc(3 * sizeof(int));
    int uniqueCount = 0;
    int prev = sums[0] + 1; // Different from first element
    
    for (int i = 0; i < sumCount && uniqueCount < 3; i++) {
        if (sums[i] != prev) {
            result[uniqueCount++] = sums[i];
            prev = sums[i];
        }
    }
    
    *returnSize = uniqueCount;
    return result;
}

// Dummy input parser for testing - in real scenario would read from stdin
int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Simple hardcoded test for demo - in real scenario would parse JSON
    int grid1[1][3] = {{7,7,7}};
    int* gridPtr1[1] = {grid1[0]};
    int gridColSize1[1] = {3};
    
    int returnSize;
    int* result = solution(gridPtr1, 1, gridColSize1, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    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