Print FooBar Alternately - Practice Coding Problems

Print FooBar Alternately - Problem

Concurrency Medium

You're given a FooBar class that contains two methods: foo() and bar(). Each method runs in a loop n times, printing either "foo" or "bar" respectively.

The challenge is that the same instance of FooBar will be accessed by two different threads simultaneously:

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

Your task is to modify the class to ensure that the output is always "foobar" repeated n times, with proper alternation between the two strings.

Example: If n=3, the expected output should be: foobarfoobarfoobar

This is a classic thread synchronization problem where you need to coordinate two threads to produce alternating output in the correct order.

Input & Output

example_1.py — Basic Case

$ Input: n = 1

› Output: foobar

💡 Note: With n=1, foo() runs once printing 'foo', then bar() runs once printing 'bar', resulting in 'foobar'

example_2.py — Multiple Iterations

$ Input: n = 3

› Output: foobarfoobarfoobar

💡 Note: With n=3, the pattern 'foobar' repeats 3 times with perfect alternation between the two threads

example_3.py — Edge Case

$ Input: n = 0

› Output:

💡 Note: When n=0, neither thread executes their loop, so no output is produced

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each thread executes n times with minimal synchronization overhead, no busy waiting

✓ Linear Growth

Space Complexity

O(1)

Only one mutex, one condition variable, and one boolean state variable needed

✓ Linear Space

Constraints

1 ≤ n ≤ 1000
Two threads will call foo() and bar() concurrently
Output must be exactly 'foobar' repeated n times
No other output patterns are acceptable

Asked in

The optimal solution uses mutex with condition variables to coordinate thread execution. Each thread waits efficiently (no busy waiting) until it's their turn, prints their string, updates the shared state, and signals the other thread. This creates perfect alternation with O(n) time complexity and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ No Synchronization (Incorrect)	O(n)	O(1)	Let both threads run without coordination - demonstrates the problem
Semaphore-Based Synchronization	O(n)	O(1)	Use two semaphores to coordinate alternating execution between threads
Mutex with Condition Variables (Optimal)	O(n)	O(1)	Use mutex and condition variables for efficient thread coordination

No Synchronization (Incorrect) — Algorithm Steps

Thread A runs foo() method independently
Thread B runs bar() method independently
Output becomes unpredictable: could be "foofoofoobarbarbar" or any random mix

Visualization

Tap to expand

Step-by-Step Walkthrough

Both threads start

Thread A and B begin execution simultaneously

Random execution

Threads execute at different speeds, creating unpredictable output

Mixed output

Result could be any permutation of foo and bar strings

Code -

solution.c — C

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

typedef struct {
    int n;
    char output[1000];
    int output_pos;
    pthread_mutex_t mutex;
} FooBar;

void* foo_thread(void* arg) {
    FooBar* fb = (FooBar*)arg;
    for (int i = 0; i < fb->n; i++) {
        usleep((rand() % 10) * 1000);
        pthread_mutex_lock(&fb->mutex);
        strcpy(&fb->output[fb->output_pos], "foo");
        fb->output_pos += 3;
        pthread_mutex_unlock(&fb->mutex);
    }
    return NULL;
}

void* bar_thread(void* arg) {
    FooBar* fb = (FooBar*)arg;
    for (int i = 0; i < fb->n; i++) {
        usleep((rand() % 10) * 1000);
        pthread_mutex_lock(&fb->mutex);
        strcpy(&fb->output[fb->output_pos], "bar");
        fb->output_pos += 3;
        pthread_mutex_unlock(&fb->mutex);
    }
    return NULL;
}

int main() {
    FooBar fb = {3, "", 0};
    pthread_mutex_init(&fb.mutex, NULL);
    
    pthread_t thread_a, thread_b;
    pthread_create(&thread_a, NULL, foo_thread, &fb);
    pthread_create(&thread_b, NULL, bar_thread, &fb);
    
    pthread_join(thread_a, NULL);
    pthread_join(thread_b, NULL);
    
    fb.output[fb.output_pos] = '\0';
    printf("Result: %s\n", fb.output);
    printf("Expected: foobarfoobarfoobar\n");
    
    pthread_mutex_destroy(&fb.mutex);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each thread prints n times

✓ Linear Growth

Space Complexity

O(1)

No additional data structures needed

✓ Linear Space

Constraints

1 ≤ n ≤ 1000
Two threads will call foo() and bar() concurrently
Output must be exactly 'foobar' repeated n times
No other output patterns are acceptable

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

No Synchronization (Incorrect) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler