Can Make Palindrome from Substring - Practice Coding Problems

Can Make Palindrome from Substring - Problem

Array Hash Table String Bit Manipulation Prefix Sum Medium

Can Make Palindrome from Substring is a fascinating problem that combines string manipulation, bit manipulation, and palindrome properties.

You're given a string s and multiple queries. For each query [left, right, k], you need to determine if the substring s[left...right] can be rearranged and have up to k characters replaced to form a palindrome.

Key Operations Allowed:
1. Rearrange characters in the substring in any order
2. Replace up to k characters with any lowercase letter

Goal: Return a boolean array where each element indicates whether the corresponding query can form a palindrome.

Example: For substring "abcd" with k=2, we can rearrange to "abdc" and replace "bd" with "aa" to get "aaac", then rearrange to "acaa" - but this isn't optimal. Better: rearrange to "abcd", replace "cd" with "ab" to get "abab", then rearrange to "abba" (palindrome!).

Input & Output

example_1.py — Basic Queries

$ Input: s = "abcda", queries = [[3,3,0],[1,2,0],[0,3,1],[0,3,2],[0,4,1]]

› Output: [true, false, false, true, true]

💡 Note: Query [3,3,0]: substring='d', already palindrome. Query [1,2,0]: substring='bc', 2 odd chars, need 1 replacement but k=0. Query [0,3,1]: substring='abcd', 4 odd chars, need 2 replacements but k=1. Query [0,3,2]: substring='abcd', need 2 replacements and k=2. Query [0,4,1]: substring='abcda', 3 odd chars, need 1 replacement and k=1.

example_2.py — Edge Cases

$ Input: s = "lyb", queries = [[0,1,0],[2,2,1]]

› Output: [false, true]

💡 Note: Query [0,1,0]: substring='ly', 2 odd chars, need 1 replacement but k=0. Query [2,2,1]: substring='b', already palindrome (single character).

example_3.py — All Same Characters

$ Input: s = "aaaa", queries = [[0,3,0],[1,2,1]]

› Output: [true, true]

💡 Note: Query [0,3,0]: substring='aaaa', all same chars (even count), already palindrome. Query [1,2,1]: substring='aa', even count, already palindrome.

Visualization

Tap to expand

Understanding the Visualization

Count Character Frequencies

For each character in the substring, count how many times it appears

Identify Unpaired Characters

Characters with odd frequencies can't all be paired - some will be left over

Calculate Minimum Replacements

Need to replace (oddCount / 2) characters to make pairs for palindrome sides

Check Against K

If minimum replacements ≤ k, we can form a palindrome

Key Takeaway

🎯 Key Insight: A palindrome needs at most 1 character with odd frequency. Count odd frequencies and check if (oddCount/2) ≤ k replacements can fix the imbalance.

Time & Space Complexity

Time Complexity

⏱️

O(N + Q)

O(N) to build prefix array, O(1) per query to calculate XOR and count bits

✓ Linear Growth

Space Complexity

O(N)

Store prefix XOR array of size N+1

✓ Linear Space

Constraints

1 ≤ s.length, queries.length ≤ 10⁵
0 ≤ left_i ≤ right_i < s.length
0 ≤ k_i ≤ s.length
s consists only of lowercase English letters
Each query is independent - no modifications persist

Asked in

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

The optimal approach uses prefix XOR with bit manipulation to efficiently track character frequency parity. Each character maps to a bit position, and XOR operations toggle bits to maintain odd/even counts. For palindromes, at most one character can have odd frequency, so we count set bits and check if (oddCount / 2) ≤ k.

Common Approaches

Approach	Time	Space	Notes
✓ Prefix Sum with Bit Manipulation (Optimal)	O(N + Q)	O(N)	Use prefix XOR to track character frequency parity efficiently
Brute Force (Count Frequencies)	O(Q * N)	O(1)	For each query, count character frequencies and calculate odd counts directly

Prefix Sum with Bit Manipulation (Optimal) — Algorithm Steps

Create prefix XOR array where each position stores XOR of all character bits up to that index
For each character, toggle corresponding bit (0-25 for a-z)
For query [left, right], XOR = prefix[right+1] ^ prefix[left]
Count set bits in XOR result (represents characters with odd frequency)
Check if (odd_count / 2) <= k

Visualization

Tap to expand

Step-by-Step Walkthrough

Map Characters to Bits

Each character a-z maps to bit position 0-25

Build Prefix XOR

XOR toggles bits, tracking odd/even frequencies

Range Query

prefix[right+1] ^ prefix[left] gives range XOR

Count Set Bits

Number of 1-bits = characters with odd frequency

Code -

solution.c — C

bool* canMakePaliQueries(char* s, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    int n = strlen(s);
    *returnSize = queriesSize;
    
    // Prefix XOR array
    int* prefix = (int*)calloc(n + 1, sizeof(int));
    
    // Build prefix XOR
    for (int i = 0; i < n; i++) {
        int charBit = 1 << (s[i] - 'a');
        prefix[i + 1] = prefix[i] ^ charBit;
    }
    
    bool* result = (bool*)malloc(queriesSize * sizeof(bool));
    for (int q = 0; q < queriesSize; q++) {
        int left = queries[q][0], right = queries[q][1], k = queries[q][2];
        
        // XOR of range [left, right]
        int xorResult = prefix[right + 1] ^ prefix[left];
        
        // Count set bits (characters with odd frequency)
        int oddCount = __builtin_popcount(xorResult);
        
        // Need at least oddCount / 2 replacements
        int minReplacements = oddCount / 2;
        
        result[q] = minReplacements <= k;
    }
    
    free(prefix);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(N + Q)

O(N) to build prefix array, O(1) per query to calculate XOR and count bits

✓ Linear Growth

Space Complexity

O(N)

Store prefix XOR array of size N+1

✓ Linear Space

Constraints

1 ≤ s.length, queries.length ≤ 10⁵
0 ≤ left_i ≤ right_i < s.length
0 ≤ k_i ≤ s.length
s consists only of lowercase English letters
Each query is independent - no modifications persist

28.4K Views

Medium Frequency

~25 min Avg. Time

842 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

Prefix Sum with Bit Manipulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler