Longest Unequal Adjacent Groups Subsequence I

Longest Unequal Adjacent Groups Subsequence I - Problem

You are given a string array words and a binary array groups both of length n.

A subsequence of words is alternating if for any two consecutive strings in the sequence, their corresponding elements at the same indices in groups are different (that is, there cannot be consecutive 0 or 1).

Your task is to select the longest alternating subsequence from words.

Return the selected subsequence. If there are multiple answers, return any of them.

Note: The elements in words are distinct.

Input & Output

Example 1 — Basic Alternating Pattern

$ Input: words = ["e","a","b"], groups = [0,0,1]

› Output: ["e","b"]

💡 Note: Start with "e" (group 0). Skip "a" (group 0, same as previous). Add "b" (group 1, different). Result: ["e","b"] alternates 0→1.

Example 2 — All Different Groups

$ Input: words = ["a","b","c","d"], groups = [1,0,1,1]

› Output: ["a","b","c"]

💡 Note: Start with "a" (group 1). Add "b" (group 0, different). Add "c" (group 1, different). Skip "d" (group 1, same as "c").

Example 3 — Single Element

$ Input: words = ["x"], groups = [1]

› Output: ["x"]

💡 Note: Only one element, so return it as the longest (and only) alternating subsequence.

Constraints

1 ≤ words.length == groups.length ≤ 10⁵
1 ≤ words[i].length ≤ 10
groups[i] is either 0 or 1
All strings in words are distinct

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 M Microsoft 8

The greedy approach is optimal for this problem. We start with the first word and scan left to right, adding each word whose group value differs from the previously selected word's group. This automatically creates the longest alternating subsequence. Time: O(n), Space: O(1)

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force - Check All Subsequences

⏱️ Time: O(n × 2ⁿ) Space: O(n)

Generate all 2^n possible subsequences of words, check if each one is alternating by comparing consecutive group values, and return the longest valid subsequence.

Greedy - Single Pass Selection

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

Start with the first word and greedily add each subsequent word whose group value differs from the previous selected word's group value. This automatically creates the longest possible alternating subsequence.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

char** parseStringArray(char* line, int* count) {
    *count = 0;
    char** result = NULL;
    
    char* ptr = strchr(line, '[');
    if (!ptr) return NULL;
    ptr++; // Skip [
    
    // Count strings first
    char* temp = ptr;
    while (*temp && *temp != ']') {
        if (*temp == '"') (*count)++;
        temp++;
    }
    *count /= 2; // Each string has opening and closing quotes
    
    if (*count == 0) return NULL;
    
    result = (char**)malloc(*count * sizeof(char*));
    
    int idx = 0;
    while (*ptr && *ptr != ']' && idx < *count) {
        // Skip to opening quote
        while (*ptr && *ptr != '"') ptr++;
        if (*ptr != '"') break;
        ptr++; // Skip opening quote
        
        // Find closing quote
        char* start = ptr;
        while (*ptr && *ptr != '"') ptr++;
        
        int len = ptr - start;
        result[idx] = (char*)malloc((len + 1) * sizeof(char));
        strncpy(result[idx], start, len);
        result[idx][len] = '\0';
        
        idx++;
        if (*ptr == '"') ptr++; // Skip closing quote
    }
    
    return result;
}

int* parseIntArray(char* line, int* count) {
    *count = 0;
    int* result = NULL;
    
    char* ptr = strchr(line, '[');
    if (!ptr) return NULL;
    ptr++; // Skip [
    
    // Count numbers first
    char* temp = ptr;
    while (*temp && *temp != ']') {
        if (*temp >= '0' && *temp <= '9') {
            (*count)++;
            while (*temp >= '0' && *temp <= '9') temp++;
        } else {
            temp++;
        }
    }
    
    if (*count == 0) return NULL;
    
    result = (int*)malloc(*count * sizeof(int));
    
    int idx = 0;
    while (*ptr && *ptr != ']' && idx < *count) {
        // Skip to next digit
        while (*ptr && (*ptr < '0' || *ptr > '9')) ptr++;
        if (*ptr < '0' || *ptr > '9') break;
        
        int num = 0;
        while (*ptr >= '0' && *ptr <= '9') {
            num = num * 10 + (*ptr - '0');
            ptr++;
        }
        result[idx] = num;
        idx++;
    }
    
    return result;
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int wordCount, groupCount;
    char** words = parseStringArray(line1, &wordCount);
    int* groups = parseIntArray(line2, &groupCount);
    
    if (!words || !groups || wordCount != groupCount || wordCount == 0) {
        printf("[]");
        return 0;
    }
    
    // Find longest alternating subsequence
    char** result = (char**)malloc(wordCount * sizeof(char*));
    int resultCount = 0;
    
    // Always include first element
    result[0] = words[0];
    resultCount = 1;
    int lastGroup = groups[0];
    
    // Greedily add elements with different group from last selected
    for (int i = 1; i < wordCount; i++) {
        if (groups[i] != lastGroup) {
            result[resultCount] = words[i];
            resultCount++;
            lastGroup = groups[i];
        }
    }
    
    // Output result
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        printf("\"%s\"", result[i]);
        if (i < resultCount - 1) printf(",");
    }
    printf("]\n");
    
    // Cleanup
    for (int i = 0; i < wordCount; i++) {
        free(words[i]);
    }
    free(words);
    free(groups);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

22.3K Views

Medium Frequency

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