Maximum Product of Word Lengths - Practice Coding Problems

Maximum Product of Word Lengths - Problem

Given an array of unique strings, find the maximum product of lengths of two words that share no common letters.

Your task is to identify pairs of words where:

No character appears in both words
The product of their lengths is maximized

For example, given ["abcw", "baz", "foo", "bar", "xtfn", "abcdef"], the words "abcw" and "xtfn" share no common letters, so their product is 4 × 4 = 16.

If no such pair exists, return 0.

Input & Output

example_1.py — Basic Case

$ Input: ["abcw", "baz", "foo", "bar", "xtfn", "abcdef"]

› Output: 16

💡 Note: The two words "abcw" and "xtfn" share no common letters, and their length product is 4 × 4 = 16, which is the maximum possible.

example_2.py — No Valid Pairs

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

› Output: 0

💡 Note: All words contain the letter 'a', so no two words can be found that don't share common letters.

example_3.py — Single Characters

$ Input: ["a", "b", "c", "d"]

› Output: 1

💡 Note: Any two single-character words with different letters will work. The maximum product is 1 × 1 = 1.

Constraints

2 ≤ words.length ≤ 1000
1 ≤ words[i].length ≤ 1000
words[i] consists only of lowercase English letters
All strings in words are unique

Visualization

Tap to expand

Understanding the Visualization

Agent Recruitment

Each agent brings a codebook with unique letters

Compatibility Check

Two agents are compatible if their alphabets don't overlap

Mission Capacity

Mission success depends on total vocabulary size (product of lengths)

Optimal Pairing

Find the compatible pair with maximum combined capacity

Key Takeaway

🎯 Key Insight: Bitmasks transform character set comparisons from O(k) set operations to O(1) bitwise operations, making pair checking extremely efficient for small alphabets.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 25

The optimal approach uses bit manipulation to represent each word's character set as a bitmask. This reduces character overlap checking from O(k) to O(1) using bitwise AND operations, achieving O(n² + nk) time complexity where n is the number of words and k is the average word length.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops with Set Intersection)	O(n² × k)	O(k)	Check every pair of words by comparing their character sets
Two-Pass with Bitmask Optimization	O(n × k + n²)	O(n)	Precompute bitmasks for each word, then compare pairs efficiently

Brute Force (Nested Loops with Set Intersection) — Algorithm Steps

Convert each word to a set of characters
Compare every pair of words using nested loops
Check if their character sets have any intersection
If no common characters, calculate length product
Track and return the maximum product found

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Sets

Transform each word into a character set

Compare Pairs

Check every combination of two words

Find Intersection

See if character sets overlap

Calculate Product

If no overlap, compute length product

Code -

solution.c — C

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

int maxProduct(char** words, int wordsSize) {
    int maxProduct = 0;
    
    for (int i = 0; i < wordsSize; i++) {
        for (int j = i + 1; j < wordsSize; j++) {
            // Check if words share any common characters
            bool chars1[26] = {false};
            bool chars2[26] = {false};
            
            // Mark characters in first word
            for (int k = 0; words[i][k]; k++) {
                chars1[words[i][k] - 'a'] = true;
            }
            
            // Mark characters in second word
            for (int k = 0; words[j][k]; k++) {
                chars2[words[j][k] - 'a'] = true;
            }
            
            // Check for common characters
            bool hasCommon = false;
            for (int k = 0; k < 26; k++) {
                if (chars1[k] && chars2[k]) {
                    hasCommon = true;
                    break;
                }
            }
            
            if (!hasCommon) {
                int product = strlen(words[i]) * strlen(words[j]);
                if (product > maxProduct) {
                    maxProduct = product;
                }
            }
        }
    }
    
    return maxProduct;
}

int main() {
    char* words[] = {"abcw", "baz", "foo", "bar", "xtfn", "abcdef"};
    printf("%d\n", maxProduct(words, 6));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × k)

n² for checking all pairs, k for average character set intersection

⚠ Quadratic Growth

Space Complexity

O(k)

Space for storing character sets of current pair

✓ Linear Space

42.5K Views

Medium Frequency

~15 min Avg. Time

1.8K 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 (Nested Loops with Set Intersection) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler