Number of Pairs of Strings With Concatenation Equal to Target

Number of Pairs of Strings With Concatenation Equal to Target - Problem

You're given an array of digit strings nums and a target digit string. Your mission is to find how many pairs of strings from the array can be concatenated together to form the target string.

More specifically, you need to count the number of pairs of indices (i, j) where i != j such that concatenating nums[i] + nums[j] equals the target.

Example: If nums = ["777", "7", "77", "77"] and target = "7777", then nums[1] + nums[0] = "7" + "777" = "7777" forms one valid pair.

Note: The order matters! nums[i] + nums[j] is different from nums[j] + nums[i] unless both strings are identical.

Input & Output

example_1.py — Basic Case

$ Input: nums = ["777","7","77","77"], target = "7777"

› Output: 4

💡 Note: Valid pairs: (1,0): "7"+"777", (0,1): "777"+"7", (2,1): "77"+"7"+"7" (invalid), actually (2,0) and (3,0) don't work. Let me recalculate: "7"+"777"="7777" ✓, "777"+"7"="7777" ✓. That's 2 pairs total.

example_2.py — No Valid Pairs

$ Input: nums = ["123","4","12","34"], target = "1234"

› Output: 2

💡 Note: Valid pairs: (2,3): "12"+"34"="1234" ✓, (0,1): "123"+"4"="1234" ✓. Total of 2 pairs.

example_3.py — Duplicate Strings

$ Input: nums = ["1","1","1"], target = "11"

› Output: 6

💡 Note: Each "1" can pair with every other "1". With 3 strings, we have 3×2=6 ordered pairs: (0,1), (0,2), (1,0), (1,2), (2,0), (2,1).

Constraints

2 ≤ nums.length ≤ 100
1 ≤ nums[i].length, target.length ≤ 100
nums[i] and target consist of digits only
All strings contain only digits 0-9

Visualization

Tap to expand

Understanding the Visualization

Identify Pieces

Each string in the array is a puzzle piece

Find Complements

For each piece, find what other piece would complete the target

Count Matches

Count all valid piece combinations that form the complete target

Key Takeaway

🎯 Key Insight: Every valid concatenation corresponds to a unique way to split the target string into a prefix and suffix, both of which must exist in our input array.

Asked in

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

The optimal solution uses a one-pass hash table approach. For each string, we check if it can form valid pairs with previously processed strings by testing all possible splits of the target. The key insight is that if string A + string B = target, then A must be a prefix and B must be the corresponding suffix of the target. This gives us O(n × m) time complexity where n is array length and m is target length.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n² × m)	O(1)	Check every possible pair of strings by concatenating them
One-Pass Hash Table (Optimal)	O(n × m)	O(n)	Process each string while building frequency map for maximum efficiency
Two-Pass Hash Table	O(n + m²)	O(n)	Build frequency map first, then search for valid prefix-suffix pairs

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each string in the array as the first part
For each first string, iterate through all other strings as the second part
Concatenate the two strings and compare with target
Count matches where indices are different

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with count = 0, examine all pairs

Check Pairs

For each pair (i,j) where i≠j, concatenate and compare

Count Matches

Increment counter when concatenation equals target

Code -

solution.c — C

int numOfPairs(char** nums, int numsSize, char* target) {
    int count = 0;
    char temp[1001];  // Assuming max length constraint
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = 0; j < numsSize; j++) {
            if (i != j) {
                strcpy(temp, nums[i]);
                strcat(temp, nums[j]);
                if (strcmp(temp, target) == 0) {
                    count++;
                }
            }
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m)

n² for checking all pairs, m for string concatenation and comparison (where m is target length)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

890 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