Palindrome Pairs

Palindrome Pairs - Problem

You are given a 0-indexed array of unique strings words. A palindrome pair is a pair of integers (i, j) such that:

0 <= i, j < words.length
i != j
words[i] + words[j] (the concatenation of the two strings) is a palindrome

Return an array of all the palindrome pairs of words. You must write an algorithm with O(sum of words[i].length) runtime complexity.

Input & Output

Example 1 — Multiple Palindrome Pairs

$ Input: words = ["race","car"]

› Output: [[0,1]]

💡 Note: "race" + "car" = "racecar" which is a palindrome. So pair (0,1) is valid.

Example 2 — No Pairs Found

$ Input: words = ["abcd","dcba","lls","s","sssll"]

› Output: [[0,1],[1,0],[3,2],[2,4]]

💡 Note: "abcd" + "dcba" = "abcddcba" (palindrome), "dcba" + "abcd" = "dcbaabcd" (palindrome), "s" + "lls" = "slls" (palindrome), "lls" + "sssll" = "llssssll" (palindrome)

Example 3 — Single Character Edge Case

$ Input: words = ["a",""]

› Output: [[0,1],[1,0]]

💡 Note: "a" + "" = "a" (palindrome), "" + "a" = "a" (palindrome). Both combinations work with empty string.

Constraints

1 ≤ words.length ≤ 5000
0 ≤ words[i].length ≤ 300
words[i] consists of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Facebook 32 M Microsoft 28

The key insight is that palindromes can be formed by matching word prefixes/suffixes with their reverses. The hash map approach provides efficient O(1) lookups instead of O(n) searches. Best approach uses hash map with prefix/suffix analysis: Time O(n×m²), Space O(n×m).

Common Approaches

✓ Brute Force

⏱️ Time: O(n² × m) Space: O(1)

For each pair of words (i,j), concatenate them and check if the result is a palindrome. This requires checking all possible pairs and validating each concatenation.

Hash Map with Prefix/Suffix Analysis

⏱️ Time: O(n × m²) Space: O(n × m)

Store all words with their indices in a hash map. For each word, check if its reverse exists, and handle cases where one word is a prefix/suffix of a palindrome formed with another word.

Brute Force — Algorithm Steps

Iterate through all pairs (i,j) where i ≠ j
Concatenate words[i] + words[j]
Check if concatenation is palindrome
If yes, add [i,j] to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Pair (0,1)

"race" + "car" = "racecar" → palindrome ✓

Check Pair (1,0)

"car" + "race" = "carrace" → not palindrome ✗

Result

Found palindrome pairs: [[0,1], [3,2]]

Code -

solution.c — C

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

int isPalindrome(char* s) {
    int len = strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) {
            return 0;
        }
    }
    return 1;
}

int** solution(char** words, int wordsSize, int* returnSize, int** returnColumnSizes) {
    int** result = (int**)malloc(wordsSize * wordsSize * sizeof(int*));
    *returnColumnSizes = (int*)malloc(wordsSize * wordsSize * sizeof(int));
    int count = 0;
    
    for (int i = 0; i < wordsSize; i++) {
        for (int j = 0; j < wordsSize; j++) {
            if (i != j) {
                int len1 = strlen(words[i]);
                int len2 = strlen(words[j]);
                char* combined = (char*)malloc(len1 + len2 + 1);
                strcpy(combined, words[i]);
                strcat(combined, words[j]);
                
                if (isPalindrome(combined)) {
                    result[count] = (int*)malloc(2 * sizeof(int));
                    result[count][0] = i;
                    result[count][1] = j;
                    (*returnColumnSizes)[count] = 2;
                    count++;
                }
                free(combined);
            }
        }
    }
    
    *returnSize = count;
    return result;
}

char* trim(char* str) {
    while (isspace(*str)) str++;
    char* end = str + strlen(str) - 1;
    while (end > str && isspace(*end)) {
        *end = '\0';
        end--;
    }
    return str;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    char** words = (char**)malloc(100 * sizeof(char*));
    int wordsSize = 0;
    
    char* trimmed = trim(line);
    if (strcmp(trimmed, "[]") == 0) {
        // Empty array case
        wordsSize = 0;
    } else {
        // Remove brackets
        trimmed++; // skip '['
        trimmed[strlen(trimmed) - 1] = '\0'; // remove ']'
        
        if (strlen(trimmed) > 0) {
            char* token = strtok(trimmed, ",");
            while (token != NULL) {
                token = trim(token);
                // Remove quotes
                if (token[0] == '"') {
                    token++;
                    token[strlen(token) - 1] = '\0';
                }
                words[wordsSize] = (char*)malloc(strlen(token) + 1);
                strcpy(words[wordsSize], token);
                wordsSize++;
                token = strtok(NULL, ",");
            }
        }
    }
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(words, wordsSize, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[%d,%d]", result[i][0], result[i][1]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    // Cleanup
    for (int i = 0; i < wordsSize; i++) {
        free(words[i]);
    }
    free(words);
    for (int i = 0; i < returnSize; i++) {
        free(result[i]);
    }
    free(result);
    free(returnColumnSizes);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m)

n² pairs to check, each requiring O(m) palindrome validation where m is average word length

✓ Linear Growth

Space Complexity

O(1)

Only using variables for iteration, no extra data structures

⚡ Linearithmic Space

180.0K Views

Medium Frequency

~35 min Avg. Time

2.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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler