Shortest Uncommon Substring in an Array - Practice Coding Problems

Shortest Uncommon Substring in an Array - Problem

Find the Shortest Unique Substring

You're given an array of n non-empty strings. Your task is to find, for each string, the shortest substring that appears only in that string and nowhere else in the array.

Requirements:
• Find the shortest substring of each string that doesn't occur in any other string
• If multiple shortest substrings exist, choose the lexicographically smallest one
• If no unique substring exists, return an empty string for that position

Example: Given ["cab", "ad", "bad", "c"], the answer is ["ca", "a", "b", "c"] because:
• "ca" from "cab" doesn't appear in other strings
• "a" from "ad" is unique (though "a" exists in "bad", "ad" doesn't contain "ba")
• "b" from "bad" is the shortest unique substring
• "c" is already unique

Input & Output

example_1.py — Basic Case

$ Input: ["cab", "ad", "bad", "c"]

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

💡 Note: For "cab": "ca" is the shortest unique substring (doesn't appear in others). For "ad": "a" is unique to this string's position. For "bad": "b" is the shortest unique. For "c": the entire string "c" is unique.

example_2.py — Lexicographical Selection

$ Input: ["abc", "acd", "bcd"]

› Output: ["ab", "ac", "bc"]

💡 Note: Each string has multiple unique substrings of length 2, but we select the lexicographically smallest one. "ab" < "bc", "ac" < "cd", "bc" < "cd".

example_3.py — No Unique Substring

$ Input: ["abc", "abc"]

› Output: ["", ""]

💡 Note: Both strings are identical, so no substring can be unique to either string. Both return empty strings.

Visualization

Tap to expand

Understanding the Visualization

Catalog all fingerprints

Extract all possible fingerprints (substrings) from every document

Count occurrences

Track how many times each fingerprint appears across all documents

Find unique markers

For each document, find fingerprints that appear only in that document

Select optimal identifier

Choose the shortest, alphabetically first unique fingerprint

Key Takeaway

🎯 Key Insight: The algorithm systematically checks substrings by increasing length and lexicographical order, ensuring we find the optimal (shortest, alphabetically smallest) unique identifier for each string.

Time & Space Complexity

Time Complexity

⏱️

O(n * m³)

For n strings of average length m, we generate O(m²) substrings per string and check each against all n strings, each check taking O(m) time

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables (not counting the output array)

✓ Linear Space

Constraints

n == arr.length
2 ≤ n ≤ 100
1 ≤ arr[i].length ≤ 20
arr[i] consists of lowercase English letters
All strings are non-empty

Asked in

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

The optimal approach uses a two-pass hash table method. First pass builds a frequency map of all substrings from all strings. Second pass finds the shortest unique substring for each string by checking substrings in order of increasing length and selecting the lexicographically smallest among equal-length candidates. Time complexity is O(n × m³) where n is the number of strings and m is the average string length.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Substrings)	O(n * m³)	O(1)	Generate all substrings for each string and check uniqueness against all others
Two-Pass Hash Table	O(n * m³)	O(n * m³)	Build substring frequency map first, then find shortest unique substring for each string

Brute Force (Generate All Substrings) — Algorithm Steps

For each string in the array
Generate all substrings of length 1, then 2, then 3, etc.
For each substring, check if it appears in any other string
Return the first unique substring found
If no unique substring exists, return empty string

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with length 1

Generate all single characters from first string

Check uniqueness

Verify each substring doesn't exist in other strings

Move to length 2

If no unique substring found, try longer substrings

Return first unique

Return lexicographically smallest unique substring

Code -

solution.c — C

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

char** solution(char** arr, int n, int* returnSize) {
    char** result = (char**)malloc(n * sizeof(char*));
    *returnSize = n;
    
    for (int i = 0; i < n; i++) {
        char* currentStr = arr[i];
        int currentLen = strlen(currentStr);
        int found = 0;
        result[i] = (char*)malloc(currentLen + 1);
        result[i][0] = '\0';
        
        // Try all possible substring lengths
        for (int length = 1; length <= currentLen && !found; length++) {
            char candidates[1000][101];
            int candidateCount = 0;
            
            // Generate all substrings of current length
            for (int start = 0; start <= currentLen - length; start++) {
                char substring[101];
                strncpy(substring, currentStr + start, length);
                substring[length] = '\0';
                
                // Check if this substring exists in other strings
                int unique = 1;
                for (int j = 0; j < n; j++) {
                    if (i != j && strstr(arr[j], substring) != NULL) {
                        unique = 0;
                        break;
                    }
                }
                
                if (unique) {
                    strcpy(candidates[candidateCount], substring);
                    candidateCount++;
                }
            }
            
            // If we found candidates, pick lexicographically smallest
            if (candidateCount > 0) {
                strcpy(result[i], candidates[0]);
                for (int k = 1; k < candidateCount; k++) {
                    if (strcmp(candidates[k], result[i]) < 0) {
                        strcpy(result[i], candidates[k]);
                    }
                }
                found = 1;
            }
        }
        
        if (!found) {
            strcpy(result[i], "");
        }
    }
    
    return result;
}

int main() {
    char* arr[] = {"cab", "ad", "bad", "c"};
    int returnSize;
    char** result = solution(arr, 4, &returnSize);
    for (int i = 0; i < returnSize; i++) {
        printf("%s ", result[i]);
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m³)

For n strings of average length m, we generate O(m²) substrings per string and check each against all n strings, each check taking O(m) time

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables (not counting the output array)

✓ Linear Space

Constraints

n == arr.length
2 ≤ n ≤ 100
1 ≤ arr[i].length ≤ 20
arr[i] consists of lowercase English letters
All strings are non-empty

42.0K Views

Medium Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Generate All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler