Occurrences After Bigram - Practice Coding Problems

Occurrences After Bigram - Problem

String Easy

You're given two strings first and second, and a text string containing multiple words. Your task is to find all occurrences of the pattern "first second third" in the text, where:

second comes immediately after first
third comes immediately after second

Return an array of all the third words that complete this pattern.

Example: If first = "we", second = "will", and text = "we will rock you we will go there", you should return ["rock", "go"] because both "we will rock" and "we will go" match the pattern.

Input & Output

example_1.py — Basic Pattern Matching

$ Input: text = "we will rock you we will go there", first = "we", second = "will"

› Output: ["rock", "go"]

💡 Note: Found two occurrences of 'we will': 'we will rock' and 'we will go'. The third words are 'rock' and 'go'.

example_2.py — Single Match

$ Input: text = "alice is a good girl she is a good student", first = "a", second = "good"

› Output: ["girl", "student"]

💡 Note: Found two patterns 'a good': 'a good girl' and 'a good student'. Return both third words.

example_3.py — No Matches

$ Input: text = "hello world how are you", first = "we", second = "will"

› Output: []

💡 Note: The pattern 'we will' does not exist in the text, so return empty array.

Constraints

1 ≤ text.length ≤ 1000
text consists of lowercase English letters and spaces
All words in text are separated by single space
1 ≤ first.length, second.length ≤ 10
first and second consist of lowercase English letters

Visualization

Tap to expand

Understanding the Visualization

Setup Window

Create a sliding window that tracks the last 2 words seen

Scan Text

Move through each word, checking if the window contains our target pattern

Pattern Match

When the pattern matches, record the current word as a result

Update Window

Shift the window forward by updating the tracked words

Key Takeaway

🎯 Key Insight: By maintaining a sliding window of the last 2 words, we can detect patterns in O(n) time with O(1) space, making this much more efficient than checking every possible position.

Asked in

G Google 15 a Amazon 8 ⊞ Microsoft 6 f Meta 4

The optimal approach uses sequential tracking to scan the text in a single pass. We maintain two variables to track the previous two words, and whenever they match our target pattern, we collect the current word. This achieves O(n) time complexity with O(1) extra space for tracking.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Sequential Tracking (Optimal)	O(n)	O(k)	Track the last two words while iterating through the text once
Brute Force (Check Every Position)	O(n)	O(k)	Check every possible starting position for the three-word pattern

One-Pass Sequential Tracking (Optimal) — Algorithm Steps

Split the text into words array
Initialize variables to track previous two words
Iterate through each word starting from index 2
Check if previous two words match the pattern 'first second'
If they match, add current word to results and update tracking variables

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Tracking

Start with first two words as prev2 and prev1

Scan Forward

For each subsequent word, check if prev2+prev1 matches pattern

Update State

Shift tracking variables: prev2=prev1, prev1=current

Collect Matches

When pattern matches, add current word to results

Code -

solution.c — C

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

char** findOcurrences(char* text, char* first, char* second, int* returnSize) {
    char** result = malloc(1000 * sizeof(char*));
    *returnSize = 0;
    
    // Tokenize the text
    char* words[1000];
    int wordCount = 0;
    char* token = strtok(text, " ");
    
    while (token != NULL && wordCount < 1000) {
        words[wordCount] = malloc(strlen(token) + 1);
        strcpy(words[wordCount], token);
        wordCount++;
        token = strtok(NULL, " ");
    }
    
    if (wordCount < 3) {
        // Free allocated words
        for (int i = 0; i < wordCount; i++) {
            free(words[i]);
        }
        return result;
    }
    
    // Track previous two words
    char* prev2 = words[0];
    char* prev1 = words[1];
    
    // Start checking from the third word
    for (int i = 2; i < wordCount; i++) {
        if (strcmp(prev2, first) == 0 && strcmp(prev1, second) == 0) {
            result[*returnSize] = malloc(strlen(words[i]) + 1);
            strcpy(result[*returnSize], words[i]);
            (*returnSize)++;
        }
        // Update tracking variables
        prev2 = prev1;
        prev1 = words[i];
    }
    
    // Free temporary words array
    for (int i = 0; i < wordCount; i++) {
        free(words[i]);
    }
    
    return result;
}

int main() {
    char text[1000], first[100], second[100];
    fgets(text, sizeof(text), stdin);
    fgets(first, sizeof(first), stdin);
    fgets(second, sizeof(second), stdin);
    
    // Remove newlines and quotes
    text[strcspn(text, "\n")] = 0;
    first[strcspn(first, "\n")] = 0;
    second[strcspn(second, "\n")] = 0;
    
    if (text[0] == '"') {
        memmove(text, text + 1, strlen(text));
        text[strlen(text) - 1] = '\0';
    }
    if (first[0] == '"') {
        memmove(first, first + 1, strlen(first));
        first[strlen(first) - 1] = '\0';
    }
    if (second[0] == '"') {
        memmove(second, second + 1, strlen(second));
        second[strlen(second) - 1] = '\0';
    }
    
    int returnSize;
    char** result = findOcurrences(text, first, second, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(", ");
        free(result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the text with constant time operations per word

✓ Linear Growth

Space Complexity

O(k)

Where k is the number of matches found (result array size)

✓ Linear Space

28.4K Views

Medium Frequency

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

One-Pass Sequential Tracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler