Before and After Puzzle - Practice Coding Problems

Before and After Puzzle - Problem

Imagine you're creating a word puzzle game where you combine two phrases into one by merging their overlapping words! This is exactly what a Before and After Puzzle does.

Given a list of phrases (strings with lowercase letters and spaces only), you need to find all possible Before and After combinations. Here's how it works:

Take two different phrases where the last word of the first phrase matches the first word of the second phrase
Merge them by combining the overlapping word (don't duplicate it!)
For example: "mission statement" + "statement of purpose" = "mission statement of purpose"

Important rules:

Order matters: both phrases[i] + phrases[j] and phrases[j] + phrases[i] should be considered
A phrase cannot be combined with itself (i ≠ j)
Return all unique combinations sorted lexicographically

Input & Output

example_1.py — Python

$ Input: ["writing code", "code review"]

› Output: ["writing code review"]

💡 Note: The last word of "writing code" is "code", which matches the first word of "code review". We merge them to get "writing code review" (note we don't duplicate "code").

example_2.py — Python

$ Input: ["mission statement", "a quick bite to eat", "a chip off the old block", "chocolate chip cookie", "cookie monster"]

› Output: ["a chip off the old block", "a quick bite to eat", "chocolate chip cookie monster"]

💡 Note: Multiple combinations are possible: "chocolate chip" + "chip off the old block", "a quick bite to" + "to eat" (but "to eat" is not in the input), and "chocolate chip cookie" + "cookie monster".

example_3.py — Python

$ Input: ["a", "aa", "aaa"]

› Output: ["a aa", "a aaa", "aa aaa"]

💡 Note: Edge case with single words: "a" + "aa" = "a aa", "a" + "aaa" = "a aaa", "aa" + "aaa" = "aa aaa".

Constraints

1 ≤ phrases.length ≤ 100
1 ≤ phrases[i].length ≤ 1000
All phrases contain only lowercase English letters and spaces
No leading or trailing spaces
No consecutive spaces within phrases

Visualization

Tap to expand

Understanding the Visualization

Map the Islands

Create a directory of all islands organized by their first building

Find Connections

For each island, look up which other islands can be reached from its last building

Build Bridges

Connect compatible islands by merging their buildings without duplicating the connecting point

Key Takeaway

🎯 Key Insight: Instead of checking every pair (O(n²)), group phrases by first word in a hash map, then instantly find matches for any last word in O(1) time.

Asked in

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

The optimal approach uses a hash table to group phrases by their first word, then for each phrase's last word, efficiently finds all matching combinations. This reduces the time complexity from O(n²) to O(n × m) where m is the average string operation cost.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table	O(n × m)	O(n × m)	Build hash map of first words, then find matches for last words
Brute Force (Nested Loops)	O(n² × m)	O(k × m)	Check every pair of phrases to see if they can be combined

Two-Pass Hash Table — Algorithm Steps

Create a hash map where keys are first words and values are lists of phrases starting with that word
Iterate through all phrases and populate the hash map
For each phrase, extract its last word
Look up the last word in the hash map to find all phrases that start with it
For each match, merge the phrases and add to result set
Convert result set to sorted list

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Map

Group phrases by their first word

Search Efficiently

For each phrase's last word, instantly find matching first words

Code -

solution.c — C

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

#define MAX_PHRASES 1000
#define MAX_LENGTH 100
#define HASH_SIZE 1000

typedef struct Node {
    char phrase[MAX_LENGTH];
    struct Node* next;
} Node;

Node* hashTable[HASH_SIZE];

unsigned int hash(char* str) {
    unsigned int hash = 5381;
    int c;
    while ((c = *str++)) {
        hash = ((hash << 5) + hash) + c;
    }
    return hash % HASH_SIZE;
}

void addToHash(char* firstWord, char* phrase) {
    unsigned int index = hash(firstWord);
    Node* newNode = (Node*)malloc(sizeof(Node));
    strcpy(newNode->phrase, phrase);
    newNode->next = hashTable[index];
    hashTable[index] = newNode;
}

char* extractFirstWord(char* phrase, char* buffer) {
    char* space = strchr(phrase, ' ');
    if (space) {
        int len = space - phrase;
        strncpy(buffer, phrase, len);
        buffer[len] = '\0';
    } else {
        strcpy(buffer, phrase);
    }
    return buffer;
}

char* extractLastWord(char* phrase) {
    char* lastSpace = strrchr(phrase, ' ');
    return lastSpace ? lastSpace + 1 : phrase;
}

int main() {
    char phrases[][MAX_LENGTH] = {"writing code", "code review"};
    int n = 2;
    
    // Initialize hash table
    for (int i = 0; i < HASH_SIZE; i++) {
        hashTable[i] = NULL;
    }
    
    // First pass: populate hash table
    for (int i = 0; i < n; i++) {
        char firstWord[MAX_LENGTH];
        extractFirstWord(phrases[i], firstWord);
        addToHash(firstWord, phrases[i]);
    }
    
    char results[MAX_PHRASES][MAX_LENGTH];
    int count = 0;
    
    // Second pass: find matches
    for (int i = 0; i < n; i++) {
        char* lastWord = extractLastWord(phrases[i]);
        unsigned int index = hash(lastWord);
        
        Node* current = hashTable[index];
        while (current != NULL) {
            if (strcmp(phrases[i], current->phrase) != 0) {
                char firstWord[MAX_LENGTH];
                extractFirstWord(current->phrase, firstWord);
                if (strcmp(lastWord, firstWord) == 0) {
                    char* restOfSecond = strchr(current->phrase, ' ');
                    if (restOfSecond) {
                        sprintf(results[count], "%s%s", phrases[i], restOfSecond);
                    } else {
                        strcpy(results[count], phrases[i]);
                    }
                    count++;
                }
            }
            current = current->next;
        }
    }
    
    for (int i = 0; i < count; i++) {
        printf("%s\n", results[i]);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

n phrases, m average operations per phrase for string splitting and joining

✓ Linear Growth

Space Complexity

O(n × m)

Hash map stores all phrases grouped by first word, plus result set

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

1.2K 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

Two-Pass Hash Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler