Find Longest Awesome Substring

Find Longest Awesome Substring - Problem

You are given a string s. An awesome substring is a non-empty substring of s such that we can make any number of swaps in order to make it a palindrome.

Return the length of the maximum length awesome substring of s.

Note: A palindrome is a string that reads the same forward and backward. For example, "racecar" and "aabbaa" are palindromes, while "hello" is not.

Input & Output

Example 1 — Basic Case

$ Input: s = "3242415"

› Output: 5

💡 Note: The substring "24241" can be rearranged to form the palindrome "24142" since digits 2,4,1 each appear twice and 4 appears once, satisfying the palindrome condition.

Example 2 — Single Digit

$ Input: s = "12345"

› Output: 1

💡 Note: No substring longer than 1 can form a palindrome since all digits are different. Any single digit forms a palindrome, so the answer is 1.

Example 3 — All Same Digits

$ Input: s = "213213"

› Output: 6

💡 Note: The entire string can form a palindrome (e.g., "123321") since each digit 1,2,3 appears exactly twice, all even counts.

Constraints

1 ≤ s.length ≤ 10⁵
s consists only of digits.

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 20 a Amazon 15

The key insight is that a string can form a palindrome if at most one character has an odd frequency count. The optimal approach uses bit manipulation to track digit parity states efficiently. Time: O(n), Space: O(2^k) where k=10 digits.

Common Approaches

✓ Bit Manipulation with Prefix States

⏱️ Time: O(n) Space: O(2^k)

Instead of counting frequencies, use a bitmask where each bit represents whether a digit appears an odd number of times. For a substring to form a palindrome, its state should match a previously seen state or differ by at most one bit.

Brute Force - Check All Substrings

⏱️ Time: O(n³) Space: O(1)

For every possible substring, count character frequencies and check if at most one character has an odd count (palindrome condition). Track the maximum length found.

Bit Manipulation with Prefix States — Algorithm Steps

Use bitmask to track odd/even counts of digits
Store first occurrence of each state
For each position, check if current state or states differing by one bit were seen before
Update maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize State

Start with state 0 (all digits even count)

Update Bitmask

Toggle bit for each digit encountered

Check Matches

Find previous states that allow palindromes

Code -

solution.c — C

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

#define HASH_SIZE 10007

typedef struct HashNode {
    int state;
    int index;
    struct HashNode* next;
} HashNode;

HashNode* hashTable[HASH_SIZE];

int hash(int state) {
    return ((state % HASH_SIZE) + HASH_SIZE) % HASH_SIZE;
}

void put(int state, int index) {
    int h = hash(state);
    HashNode* node = hashTable[h];
    while (node) {
        if (node->state == state) return; // don't update existing
        node = node->next;
    }
    node = (HashNode*)malloc(sizeof(HashNode));
    node->state = state;
    node->index = index;
    node->next = hashTable[h];
    hashTable[h] = node;
}

int get(int state, int* found) {
    int h = hash(state);
    HashNode* node = hashTable[h];
    while (node) {
        if (node->state == state) {
            *found = 1;
            return node->index;
        }
        node = node->next;
    }
    *found = 0;
    return -1;
}

int solution(char* s) {
    int n = strlen(s);
    memset(hashTable, 0, sizeof(hashTable));
    put(0, -1); // empty prefix has state 0
    int state = 0;
    int maxLen = 0;
    
    for (int i = 0; i < n; i++) {
        int digit = s[i] - '0';
        // Toggle bit for this digit
        state ^= (1 << digit);
        
        // Check if this exact state was seen before
        int found;
        int prevIndex = get(state, &found);
        if (found) {
            int len = i - prevIndex;
            if (len > maxLen) maxLen = len;
        } else {
            put(state, i);
        }
        
        // Check states that differ by exactly one bit
        for (int j = 0; j < 10; j++) {
            int targetState = state ^ (1 << j);
            prevIndex = get(targetState, &found);
            if (found) {
                int len = i - prevIndex;
                if (len > maxLen) maxLen = len;
            }
        }
    }
    
    return maxLen;
}

int main() {
    char s[100001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    int result = solution(s);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string with O(1) bit operations

⚠ Quadratic Growth

Space Complexity

O(2^k)

Hash map stores at most 2^10 = 1024 possible states for 10 digits

✓ Linear Space

23.5K Views

Medium 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

Bit Manipulation with Prefix States — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler