Move from brute-force thinking to an efficient approach using two pointers strategy.
You are given two strings a and b of the same length. Choose an index and split both strings at the same index, splitting a into two strings: aprefix and asuffix where a = aprefix + asuffix, and splitting b into two strings: bprefix and bsuffix where b = bprefix + bsuffix. Check if aprefix + bsuffix or bprefix + asuffix forms a palindrome.
When you split a string s into sprefix and ssuffix, either ssuffix or sprefix is allowed to be empty. For example, if s = "abc", then "" + "abc", "a" + "bc", "ab" + "c" , and "abc" + "" are valid splits.
Return true if it is possible to form a palindrome string, otherwise return false.
Notice that x + y denotes the concatenation of strings x and y.
Example 1:
Input: a = "x", b = "y" Output: true Explaination: If either a or b are palindromes the answer is true since you can split in the following way: aprefix = "", asuffix = "x" bprefix = "", bsuffix = "y" Then, aprefix + bsuffix = "" + "y" = "y", which is a palindrome.
Example 2:
Input: a = "xbdef", b = "xecab" Output: false
Example 3:
Input: a = "ulacfd", b = "jizalu" Output: true Explaination: Split them at index 3: aprefix = "ula", asuffix = "cfd" bprefix = "jiz", bsuffix = "alu" Then, aprefix + bsuffix = "ula" + "alu" = "ulaalu", which is a palindrome.
Constraints:
1 <= a.length, b.length <= 105a.length == b.lengtha and b consist of lowercase English lettersProblem summary: You are given two strings a and b of the same length. Choose an index and split both strings at the same index, splitting a into two strings: aprefix and asuffix where a = aprefix + asuffix, and splitting b into two strings: bprefix and bsuffix where b = bprefix + bsuffix. Check if aprefix + bsuffix or bprefix + asuffix forms a palindrome. When you split a string s into sprefix and ssuffix, either ssuffix or sprefix is allowed to be empty. For example, if s = "abc", then "" + "abc", "a" + "bc", "ab" + "c" , and "abc" + "" are valid splits. Return true if it is possible to form a palindrome string, otherwise return false. Notice that x + y denotes the concatenation of strings x and y.
Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.
Pattern signal: Two Pointers
"x" "y"
"xbdef" "xecab"
"ulacfd" "jizalu"
Source-backed implementations are provided below for direct study and interview prep.
// Accepted solution for LeetCode #1616: Split Two Strings to Make Palindrome
class Solution {
public boolean checkPalindromeFormation(String a, String b) {
return check1(a, b) || check1(b, a);
}
private boolean check1(String a, String b) {
int i = 0;
int j = b.length() - 1;
while (i < j && a.charAt(i) == b.charAt(j)) {
i++;
j--;
}
return i >= j || check2(a, i, j) || check2(b, i, j);
}
private boolean check2(String a, int i, int j) {
while (i < j && a.charAt(i) == a.charAt(j)) {
i++;
j--;
}
return i >= j;
}
}
// Accepted solution for LeetCode #1616: Split Two Strings to Make Palindrome
func checkPalindromeFormation(a string, b string) bool {
return check1(a, b) || check1(b, a)
}
func check1(a, b string) bool {
i, j := 0, len(b)-1
for i < j && a[i] == b[j] {
i++
j--
}
return i >= j || check2(a, i, j) || check2(b, i, j)
}
func check2(a string, i, j int) bool {
for i < j && a[i] == a[j] {
i++
j--
}
return i >= j
}
# Accepted solution for LeetCode #1616: Split Two Strings to Make Palindrome
class Solution:
def checkPalindromeFormation(self, a: str, b: str) -> bool:
def check1(a: str, b: str) -> bool:
i, j = 0, len(b) - 1
while i < j and a[i] == b[j]:
i, j = i + 1, j - 1
return i >= j or check2(a, i, j) or check2(b, i, j)
def check2(a: str, i: int, j: int) -> bool:
return a[i : j + 1] == a[i : j + 1][::-1]
return check1(a, b) or check1(b, a)
// Accepted solution for LeetCode #1616: Split Two Strings to Make Palindrome
impl Solution {
pub fn check_palindrome_formation(a: String, b: String) -> bool {
fn check1(a: &[u8], b: &[u8]) -> bool {
let (mut i, mut j) = (0, b.len() - 1);
while i < j && a[i] == b[j] {
i += 1;
j -= 1;
}
if i >= j {
return true;
}
check2(a, i, j) || check2(b, i, j)
}
fn check2(a: &[u8], mut i: usize, mut j: usize) -> bool {
while i < j && a[i] == a[j] {
i += 1;
j -= 1;
}
i >= j
}
let a = a.as_bytes();
let b = b.as_bytes();
check1(a, b) || check1(b, a)
}
}
// Accepted solution for LeetCode #1616: Split Two Strings to Make Palindrome
function checkPalindromeFormation(a: string, b: string): boolean {
const check1 = (a: string, b: string) => {
let i = 0;
let j = b.length - 1;
while (i < j && a.charAt(i) === b.charAt(j)) {
i++;
j--;
}
return i >= j || check2(a, i, j) || check2(b, i, j);
};
const check2 = (a: string, i: number, j: number) => {
while (i < j && a.charAt(i) === a.charAt(j)) {
i++;
j--;
}
return i >= j;
};
return check1(a, b) || check1(b, a);
}
Use this to step through a reusable interview workflow for this problem.
Two nested loops check every pair of elements. The outer loop picks one element, the inner loop scans the rest. For n elements that is n × (n−1)/2 comparisons = O(n²). No extra memory — just two loop variables.
Each pointer traverses the array at most once. With two pointers moving inward (or both moving right), the total number of steps is bounded by n. Each comparison is O(1), giving O(n) overall. No auxiliary data structures are needed — just two index variables.
Review these before coding to avoid predictable interview regressions.
Wrong move: Advancing both pointers shrinks the search space too aggressively and skips candidates.
Usually fails on: A valid pair can be skipped when only one side should move.
Fix: Move exactly one pointer per decision branch based on invariant.