Print FooBar Alternately

Print FooBar Alternately - Problem

Concurrency Medium

You are given a FooBar class with two methods:

foo() - prints "foo" n times
bar() - prints "bar" n times

The same instance of FooBar will be passed to two different threads:

Thread A will call foo()
Thread B will call bar()

Your task: Modify the program so that the output is "foobar" repeated n times (alternating "foo" and "bar").

For example, if n = 3, the output should be: foobarfoobarfoobar

Input & Output

Example 1 — Basic Case

$ Input: n = 1

› Output: foobar

💡 Note: Thread A prints 'foo' once, Thread B prints 'bar' once, alternating to produce 'foobar'

Example 2 — Multiple Iterations

$ Input: n = 2

› Output: foobarfoobar

💡 Note: Pattern repeats: foo-bar-foo-bar, creating 'foobarfoobar'

Example 3 — Larger Input

$ Input: n = 3

› Output: foobarfoobarfoobar

💡 Note: Three complete alternations: foo-bar-foo-bar-foo-bar

Constraints

1 ≤ n ≤ 1000
The same instance of FooBar is passed to two different threads
Thread A calls foo(), Thread B calls bar()
Output must be exactly 'foobar' repeated n times

Visualization

Tap to expand

Asked in

f Facebook 35 a Amazon 28 G Google 22 M Microsoft 18

The key insight is that two threads need synchronized turn-taking to produce alternating output. The semaphore approach is optimal as it avoids CPU waste from busy waiting. Time: O(n), Space: O(1)

Common Approaches

✓ Busy Waiting with Volatile Flag

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

Create a shared volatile flag that alternates between true/false. The foo thread waits while flag is false, prints, then sets flag to false. The bar thread waits while flag is true, prints, then sets flag to true.

Semaphore Synchronization

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

Create two semaphores: fooSema (initially 1) and barSema (initially 0). foo() waits on fooSema, prints, then signals barSema. bar() waits on barSema, prints, then signals fooSema. This eliminates busy waiting.

Busy Waiting with Volatile Flag — Algorithm Steps

Step 1: Create volatile boolean flag initialized to true
Step 2: foo() waits for flag=true, prints, sets flag=false
Step 3: bar() waits for flag=false, prints, sets flag=true

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

fooTurn=true, both threads start

Busy Wait

bar thread spins waiting, foo thread prints

Alternate

Flag flips, roles reverse

Code -

solution.c — C

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

char* solution(int n) {
    // Allocate result string: n * "foobar" = n * 6 characters + null terminator
    char* result = calloc(6 * n + 1, sizeof(char));
    int pos = 0;
    
    // Simulate alternating foo and bar output
    for (int i = 0; i < n; i++) {
        // Add "foo"
        strcpy(result + pos, "foo");
        pos += 3;
        
        // Add "bar"
        strcpy(result + pos, "bar");
        pos += 3;
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each thread prints n times, total 2n operations

✓ Linear Growth

Space Complexity

O(1)

Only uses one boolean flag variable

✓ Linear Space

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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 Volatile Flag — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler