Longest Uncommon Subsequence I - Practice Coding Problems

Longest Uncommon Subsequence I - Problem

String Easy

Given two strings a and b, find the longest uncommon subsequence between them. An uncommon subsequence is a string that is a subsequence of exactly one of the two strings (not both).

A subsequence is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.

Goal: Return the length of the longest uncommon subsequence. If no such uncommon subsequence exists, return -1.

Key Insight: Think about what makes a subsequence "uncommon" - it must belong to one string but not the other!

Input & Output

example_1.py — Different Strings

$ Input: a = "aba", b = "cdc"

› Output: 3

💡 Note: Since the strings are different, each entire string is a subsequence of exactly one string. The longest uncommon subsequence is either "aba" or "cdc", both with length 3.

example_2.py — Identical Strings

$ Input: a = "aaa", b = "aaa"

› Output: -1

💡 Note: Since both strings are identical, any subsequence of one string will also be a subsequence of the other. Therefore, no uncommon subsequence exists.

example_3.py — Different Lengths

$ Input: a = "a", b = "aa"

› Output: 2

💡 Note: The strings are different, so each string itself is an uncommon subsequence. The longer string "aa" has length 2, which is the maximum.

Constraints

1 ≤ a.length, b.length ≤ 100
a and b consist of lower-case English letters
Key insight: The maximum possible answer is max(a.length, b.length)

Visualization

Tap to expand

Understanding the Visualization

Case 1: Identical Strings

If a == b, any subsequence of a is also a subsequence of b, so no uncommon subsequence exists

Case 2: Different Strings

If a != b, then string a is a subsequence of a but NOT of b (since they're different)

Key Insight

Each entire string is itself the longest possible uncommon subsequence!

Key Takeaway

🎯 Key Insight: If strings are different, each string is its own longest uncommon subsequence!

Asked in

G Google 15 a Amazon 8 ⊞ Microsoft 5 Apple 3

This problem has a brilliant logical insight: if two strings are different, then each string itself is the longest uncommon subsequence! If the strings are identical, no uncommon subsequence exists. The answer is simply a == b ? -1 : max(a.length, b.length) - a one-liner that solves it in O(n) time!

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Subsequences)	O(2^(n+m))	O(2^(n+m))	Generate all subsequences of both strings and find the longest uncommon one

Brute Force (Generate All Subsequences) — Algorithm Steps

Generate all subsequences of string a (2^n possibilities)
Generate all subsequences of string b (2^m possibilities)
For each subsequence, check if it belongs to exactly one string
Return the length of the longest such subsequence

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate subsequences of string A

Create all 2^n possible subsequences using bit manipulation

Generate subsequences of string B

Create all 2^m possible subsequences using bit manipulation

Find uncommon subsequences

Identify subsequences that exist in exactly one set

Return maximum length

Find the longest uncommon subsequence

Code -

solution.c — C

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

#define MAX_LEN 1000

typedef struct {
    char **strings;
    int count;
    int capacity;
} StringSet;

StringSet* createStringSet() {
    StringSet *set = malloc(sizeof(StringSet));
    set->capacity = 1000;
    set->strings = malloc(set->capacity * sizeof(char*));
    set->count = 0;
    return set;
}

void addToSet(StringSet *set, char *str) {
    // Check if already exists
    for (int i = 0; i < set->count; i++) {
        if (strcmp(set->strings[i], str) == 0) return;
    }
    
    if (set->count >= set->capacity) {
        set->capacity *= 2;
        set->strings = realloc(set->strings, set->capacity * sizeof(char*));
    }
    
    set->strings[set->count] = malloc(strlen(str) + 1);
    strcpy(set->strings[set->count], str);
    set->count++;
}

int contains(StringSet *set, char *str) {
    for (int i = 0; i < set->count; i++) {
        if (strcmp(set->strings[i], str) == 0) return 1;
    }
    return 0;
}

void getSubsequences(char *s, StringSet *set) {
    int n = strlen(s);
    char subseq[MAX_LEN];
    
    for (int mask = 0; mask < (1 << n); mask++) {
        int idx = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subseq[idx++] = s[i];
            }
        }
        subseq[idx] = '\0';
        addToSet(set, subseq);
    }
}

int findLUSlength(char *a, char *b) {
    StringSet *subseqsA = createStringSet();
    StringSet *subseqsB = createStringSet();
    
    getSubsequences(a, subseqsA);
    getSubsequences(b, subseqsB);
    
    int maxLen = -1;
    
    // Check subsequences from A
    for (int i = 0; i < subseqsA->count; i++) {
        if (!contains(subseqsB, subseqsA->strings[i])) {
            int len = strlen(subseqsA->strings[i]);
            if (len > maxLen) maxLen = len;
        }
    }
    
    // Check subsequences from B
    for (int i = 0; i < subseqsB->count; i++) {
        if (!contains(subseqsA, subseqsB->strings[i])) {
            int len = strlen(subseqsB->strings[i]);
            if (len > maxLen) maxLen = len;
        }
    }
    
    return maxLen;
}

int main() {
    char line[MAX_LEN];
    char a[MAX_LEN], b[MAX_LEN];
    
    fgets(line, MAX_LEN, stdin);
    line[strcspn(line, "\n")] = 0;
    
    if (line[0] == '[') {
        sscanf(line, "[\"%[^\"]\",\"%[^\"]\"]}", a, b);
    } else {
        strcpy(a, line);
        fgets(b, MAX_LEN, stdin);
        b[strcspn(b, "\n")] = 0;
    }
    
    printf("%d\n", findLUSlength(a, b));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(n+m))

We generate 2^n subsequences from first string and 2^m from second string, then check each one

✓ Linear Growth

Space Complexity

O(2^(n+m))

Need to store all subsequences to compare them

⚡ Linearithmic Space

24.5K Views

Medium Frequency

~5 min Avg. Time

892 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

Brute Force (Generate All Subsequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler