Palindrome Rearrangement Queries - Practice Coding Problems

Palindrome Rearrangement Queries - Problem

Imagine you have a string that's like a folded paper - it has two halves that should mirror each other perfectly to form a palindrome. You're given a string s of even length n, and for each query, you can rearrange characters within specific substrings in both halves.

The Challenge: For each query [a, b, c, d], you can:

Rearrange characters in the left half substring s[a:b] (where 0 ≤ a ≤ b < n/2)
Rearrange characters in the right half substring s[c:d] (where n/2 ≤ c ≤ d < n)

Your goal is to determine if these rearrangements can make the entire string a palindrome. Each query is independent - you start fresh each time!

Example: If s = "abcdef" and query is [0,1,4,5], you can rearrange "ab" and "ef" to potentially make the whole string palindromic.

Input & Output

example_1.py — Basic Palindrome Check

$ Input: s = "abcdef", queries = [[0,1,4,5]]

› Output: [True]

💡 Note: We can rearrange 'ab' to 'ba' and 'ef' to 'fe', making the string 'bafcfe'. But we need it to be palindromic. Actually, we can rearrange 'ab' and 'ef' such that combined characters 'abef' can form palindromic pairs at positions that would make the whole string palindromic.

example_2.py — Multiple Queries

$ Input: s = "abcdba", queries = [[1,2,4,5]]

› Output: [True]

💡 Note: We can rearrange substring 'bc' and 'ba' such that the result forms a palindrome. The characters 'bcba' can be rearranged to form pairs that make the string palindromic.

example_3.py — Impossible Case

$ Input: s = "abcdef", queries = [[0,0,5,5]]

› Output: [False]

💡 Note: We can only rearrange 'a' and 'f', but the middle part 'bcde' cannot form a palindrome with the fixed characters, so it's impossible.

Constraints

n == s.length
2 ≤ n ≤ 10⁵
1 ≤ queries.length ≤ 10⁵
queries[i].length == 4
0 ≤ a_i ≤ b_i < n / 2
n / 2 ≤ c_i ≤ d_i < n
s consists only of lowercase English letters

Visualization

Tap to expand

Understanding the Visualization

Identify Flexible Zones

Mark which sections of the mirror can have their pieces rearranged

Count Glass Pieces

Count each type of glass piece in the flexible zones

Check Fixed Reflection

Ensure the fixed middle section already mirrors correctly

Validate Pairing

Confirm that pieces can be paired symmetrically (at most one leftover)

Key Takeaway

🎯 Key Insight: A palindrome is possible when character frequencies allow symmetric pairing - at most one character can have an odd count!

Asked in

G Google 42 f Meta 38 ⊞ Microsoft 31 a Amazon 27

The key insight is that a palindrome can be formed if and only if at most one character has an odd frequency. We use character frequency counting on the rearrangeable regions while ensuring fixed regions don't violate palindrome constraints. This gives us an O(q * n) time complexity solution that efficiently handles each query independently.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Character Counting	O(q * n)	O(1)	For each query, check all character frequencies in affected regions
Optimized Character Frequency Analysis	O(q * n)	O(1)	Use character frequency analysis to determine palindrome possibility in one pass

Brute Force Character Counting — Algorithm Steps

For each query, identify the four regions: left modifiable, left fixed, right fixed, right modifiable
Count character frequencies in each region
Check if modifiable regions can be rearranged to match their palindromic counterparts
Verify that fixed regions already satisfy palindrome constraints

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Regions

Split string into left modifiable, left fixed, right fixed, right modifiable

Count Characters

Count frequency of each character in modifiable regions

Check Fixed Regions

Verify that fixed regions already satisfy palindrome property

Validate Palindrome

Check if character counts can form palindromic arrangement

Code -

solution.c — C

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

bool* canMakePalindrome(char* s, int** queries, int queriesSize, int* returnSize) {
    int n = strlen(s);
    bool* result = (bool*)malloc(queriesSize * sizeof(bool));
    *returnSize = queriesSize;
    
    for (int q = 0; q < queriesSize; q++) {
        int a = queries[q][0], b = queries[q][1];
        int c = queries[q][2], d = queries[q][3];
        
        int charCount[26] = {0};
        
        // Count characters in modifiable regions
        for (int i = a; i <= b; i++) {
            charCount[s[i] - 'a']++;
        }
        
        for (int i = c; i <= d; i++) {
            charCount[s[i] - 'a']++;
        }
        
        // Check fixed regions
        bool canForm = true;
        for (int i = b + 1; i < n / 2 && i < c; i++) {
            if (s[i] != s[n - 1 - i]) {
                canForm = false;
                break;
            }
        }
        
        if (canForm) {
            int oddCount = 0;
            for (int i = 0; i < 26; i++) {
                if (charCount[i] % 2 == 1) oddCount++;
            }
            canForm = oddCount <= (b - a + 1 + d - c + 1) % 2;
        }
        
        result[q] = canForm;
    }
    
    return result;
}

int main() {
    char s[1000];
    scanf("%s", s);
    // Parse queries and call function
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(q * n)

For each of q queries, we scan up to n characters to count frequencies

✓ Linear Growth

Space Complexity

O(1)

Only need constant space for character frequency counting (26 letters)

✓ Linear Space

31.2K Views

Medium-High Frequency

~25 min Avg. Time

892 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 Character Counting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler