Find Maximum Number of String Pairs - Practice Coding Problems

Find Maximum Number of String Pairs - Problem

You're given an array of distinct strings and need to find the maximum number of pairs you can form where each pair consists of a string and its reverse.

Rules for forming pairs:

A string words[i] can be paired with words[j] if words[i] equals the reverse of words[j]
Only consider pairs where i < j (avoid counting the same pair twice)
Each string can belong to at most one pair

Goal: Return the maximum number of valid pairs you can form.

Example: Given ["abc", "cba", "def", "fed"], you can form 2 pairs: ("abc", "cba") and ("def", "fed").

Input & Output

example_1.py — Basic Case

$ Input: ["lc", "cl", "gg"]

› Output: 1

💡 Note: Only one pair can be formed: ("lc", "cl") since "lc" is the reverse of "cl". The string "gg" cannot form a pair with any other string.

example_2.py — Multiple Pairs

$ Input: ["ab", "ba", "cc"]

› Output: 1

💡 Note: We can form one pair: ("ab", "ba"). The string "cc" is its own reverse, but since all strings are distinct, it cannot form a pair with itself.

example_3.py — No Pairs

$ Input: ["aa", "bb"]

› Output: 0

💡 Note: No pairs can be formed since "aa" reversed is "aa" and "bb" reversed is "bb", but all strings in the input are distinct, so no valid pairs exist.

Constraints

1 ≤ words.length ≤ 50
1 ≤ words[i].length ≤ 300
words[i] consists of only lowercase English letters
All strings are distinct

Visualization

Tap to expand

Understanding the Visualization

Setup the Dance Floor

We have dancers with move sequences: 'abc', 'cba', 'def', 'fed'

Find Compatible Partners

Check if each dancer's reverse sequence matches any other dancer

Form Dance Pairs

'abc' pairs with 'cba', and 'def' pairs with 'fed'

Count Successful Pairs

We successfully formed 2 dancing pairs from our group!

Key Takeaway

🎯 Key Insight: Instead of comparing every dancer with every other dancer (O(n²)), we can use a 'memory book' to instantly recall if we've seen the perfect reverse partner before - making it O(n)!

Asked in

G Google 12 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal solution uses a hash set to solve this problem in O(n) time. As we iterate through each string, we check if its reverse already exists in our set. If found, we increment our pair count and remove the reverse from the set. Otherwise, we add the current string to the set. This approach is efficient because it processes each string only once and provides instant lookup for reverse strings.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n² × m)	O(n)	Compare every string with every other string to find reverse pairs
One-Pass Hash Table (Optimal)	O(n × m)	O(n × m)	Use hash set to track seen strings and find pairs in single pass

Brute Force (Nested Loops) — Algorithm Steps

Create a boolean array to track which strings are already paired
For each unpaired string i, check all unpaired strings j where j > i
If words[i] equals reverse of words[j], mark both as paired and increment count
Return the total count of pairs found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first string

Compare 'abc' with all subsequent strings

Find matching pair

When 'abc' matches reverse of 'cba', mark both as used

Continue with next unused

Move to next unused string and repeat the process

Count total pairs

Return the total number of pairs found

Code -

solution.c — C

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

void reverseString(char* str, char* reversed) {
    int len = strlen(str);
    for (int i = 0; i < len; i++) {
        reversed[i] = str[len - 1 - i];
    }
    reversed[len] = '\0';
}

int maximumNumberOfStringPairs(char words[][100], int n) {
    bool used[n];
    for (int i = 0; i < n; i++) used[i] = false;
    int pairs = 0;
    
    for (int i = 0; i < n; i++) {
        if (used[i]) continue;
        for (int j = i + 1; j < n; j++) {
            if (used[j]) continue;
            char reversed[100];
            reverseString(words[j], reversed);
            if (strcmp(words[i], reversed) == 0) {
                used[i] = used[j] = true;
                pairs++;
                break;
            }
        }
    }
    
    return pairs;
}

int main() {
    int n;
    scanf("%d", &n);
    char words[n][100];
    for (int i = 0; i < n; i++) {
        scanf("%s", words[i]);
    }
    printf("%d\n", maximumNumberOfStringPairs(words, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m)

n² for nested loops, m for string reversal and comparison where m is average string length

⚠ Quadratic Growth

Space Complexity

O(n)

Boolean array to track paired strings

⚡ Linearithmic Space

12.4K Views

Medium Frequency

~15 min Avg. Time

485 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) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler