Split Two Strings to Make Palindrome - Practice Coding Problems

Split Two Strings to Make Palindrome - Problem

You are given two strings a and b of the same length. Your task is to find if there's a way to split both strings at the same index and mix their parts to create a palindrome.

Here's how it works:

Choose any index i (can be 0 to n, where n is the string length)
Split string a into a_prefix (first i characters) and a_suffix (remaining characters)
Split string b into b_prefix (first i characters) and b_suffix (remaining characters)
Check if either a_prefix + b_suffix or b_prefix + a_suffix forms a palindrome

Important: Either part of a split can be empty. For example, splitting "abc" can give you "" + "abc", "a" + "bc", "ab" + "c", or "abc" + "".

Return true if it's possible to form a palindrome, otherwise return false.

Input & Output

example_1.py — Basic Case

$ Input: a = "x", b = "y"

› Output: true

💡 Note: We can split at position 0: "" + "x" and "" + "y" gives us "x" and "y". Or split at position 1: "x" + "" and "y" + "" gives us "x" and "y". Both "x" and "y" are single characters, so they're palindromes.

example_2.py — Found Palindrome

$ Input: a = "ulacfd", b = "jizalu"

› Output: true

💡 Note: Split at position 2: a_prefix="ul", b_suffix="zalu" → "ul" + "zalu" = "ulzalu" which is a palindrome (reads same forwards and backwards).

example_3.py — No Palindrome Possible

$ Input: a = "xbdef", b = "xecab"

› Output: false

💡 Note: No matter where we split, neither a_prefix + b_suffix nor b_prefix + a_suffix forms a palindrome. We've tried all positions 0-5 and none work.

Visualization

Tap to expand

Understanding the Visualization

Examine the Strands

We have two DNA strands of equal length that we need to cut and recombine

Try Different Cut Points

Like a scientist testing different cutting positions with molecular scissors

Swap and Test

For each cut, swap the tails and check if the result is palindromic using dual microscopes

Find Stable Configuration

A palindromic DNA sequence is found - this would be stable and valuable for research!

Key Takeaway

🎯 Key Insight: We can efficiently check for palindromic combinations by using two pointers from the edges inward, avoiding expensive string concatenations while still testing all possible split points.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) split positions × O(n) palindrome check, but with better constants due to early termination

⚠ Quadratic Growth

Space Complexity

O(1)

Only using pointers, no additional string storage needed

✓ Linear Space

Constraints

1 ≤ a.length, b.length ≤ 10⁵
a.length == b.length
a and b consist of lowercase English letters only
Both strings must have the same length

Asked in

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

The optimal approach uses two pointers to efficiently check palindrome properties without creating temporary strings. For each split position, we virtually combine a_prefix + b_suffix and b_prefix + a_suffix, then use pointers from both ends to verify palindrome properties in O(1) space. While still O(n²) time complexity, this avoids string concatenation overhead and enables early termination.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers Optimization	O(n²)	O(1)	Use two pointers to efficiently check palindrome properties without generating all combinations
Brute Force (Try All Split Points)	O(n²)	O(n)	Try every possible split point and check if resulting combinations form palindromes

Two Pointers Optimization — Algorithm Steps

Create helper function to check if a combination forms palindrome using two pointers
For each split position, use virtual concatenation instead of creating actual strings
Use two pointers (left from start, right from end) to compare characters
Handle the transition between prefix and suffix parts carefully
Return true as soon as any palindrome is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Set left=0, right=n-1 to check virtual combination

Compare Characters

Get chars from appropriate string based on pointer position vs split point

Move Inward

Move pointers toward center, return false on mismatch, true when pointers meet

Code -

solution.c — C

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

bool isVirtualPalindrome(const char* s1, const char* s2, int split, int n) {
    int left = 0, right = n - 1;
    
    while (left < right) {
        // Get left character
        char leftChar = left < split ? s1[left] : s2[left];
        // Get right character
        char rightChar = right < split ? s1[right] : s2[right];
        
        if (leftChar != rightChar) {
            return false;
        }
        left++;
        right--;
    }
    
    return true;
}

bool checkPalindrome(const char* a, const char* b) {
    int n = strlen(a);
    
    // Try all split positions
    for (int i = 0; i <= n; i++) {
        // Check a_prefix + b_suffix
        if (isVirtualPalindrome(a, b, i, n)) {
            return true;
        }
        // Check b_prefix + a_suffix
        if (isVirtualPalindrome(b, a, i, n)) {
            return true;
        }
    }
    
    return false;
}

int main() {
    char a[1001], b[1001];
    scanf("%s %s", a, b);
    printf("%s\n", checkPalindrome(a, b) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) split positions × O(n) palindrome check, but with better constants due to early termination

⚠ Quadratic Growth

Space Complexity

O(1)

Only using pointers, no additional string storage needed

✓ Linear Space

Constraints

1 ≤ a.length, b.length ≤ 10⁵
a.length == b.length
a and b consist of lowercase English letters only
Both strings must have the same length

78.2K Views

Medium-High Frequency

~18 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler