Find Longest Awesome Substring

Find Longest Awesome Substring - Problem

You're given a string s consisting only of digits. Your task is to find the longest awesome substring.

An awesome substring is a non-empty substring where you can rearrange the characters to form a palindrome. This means at most one character can have an odd frequency - all others must appear an even number of times.

Key Insight: Since we can swap characters freely, we only care about the frequency of each digit, not their positions!

Examples:

"3242415" → The substring "24241" can be rearranged to "24142" (palindrome)
"12321" → The entire string is already awesome (can form palindrome "12321")

Goal: Return the length of the maximum length awesome substring.

Input & Output

example_1.py — Basic Case

$ Input: s = "3242415"

› Output: 5

💡 Note: The longest awesome substring is "24241" (from index 1 to 5). It can be rearranged to form palindrome "24142" since digit 1 appears once (odd), digits 2 and 4 each appear twice (even).

example_2.py — Already Palindrome

$ Input: s = "12321"

› Output: 5

💡 Note: The entire string "12321" is already a palindrome and awesome. Digit frequencies: 1→2 times, 2→2 times, 3→1 time. At most one digit (3) has odd frequency.

example_3.py — Single Character

$ Input: s = "213"

› Output: 1

💡 Note: Each individual character forms an awesome substring of length 1. No longer awesome substring exists since all pairs would have different digits (each appearing once, giving 2 odd frequencies).

Constraints

1 ≤ s.length ≤ 10⁵
s consists only of digits (0-9)
An awesome substring must be non-empty
At most one character can have odd frequency for palindrome formation

Visualization

Tap to expand

Understanding the Visualization

Create Fingerprint

Each position in string creates a bitmask fingerprint representing which digits appear odd number of times

Pattern Matching

Look for previous positions with same fingerprint (all even frequencies) or fingerprint differing by exactly 1 bit (one odd frequency)

Calculate Distance

When patterns match, the substring between positions can form a palindrome - calculate its length

Track Maximum

Keep track of the longest valid substring found using this pattern matching technique

Key Takeaway

🎯 Key Insight: By representing digit frequency parity as bit patterns, we transform a complex substring problem into efficient pattern matching, achieving optimal O(n) time complexity.

Asked in

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

The optimal solution uses bit manipulation with a hash map to track frequency patterns. Each bit in a 10-bit mask represents whether a digit has odd frequency. For a palindrome, at most one bit should be set. We store the first occurrence of each mask pattern and check for same masks (all even frequencies) or masks differing by 1 bit (one odd frequency). This achieves O(n) time complexity with elegant bit operations.

Common Approaches

Approach	Time	Space	Notes
✓ Bit Manipulation + Hash Map (Optimal)	O(n)	O(min(n, 2^10))	Use bit masks to represent digit frequency parity and hash map for efficient lookup
Brute Force (Check All Substrings)	O(n³)	O(1)	Check every possible substring and verify if it can form a palindrome

Bit Manipulation + Hash Map (Optimal) — Algorithm Steps

Use a 10-bit mask to track parity (odd/even) of each digit frequency
Store the first occurrence index of each bitmask in hash map
For each position, check if current mask or any mask differing by 1 bit was seen before
Calculate length using current index minus stored first occurrence
Update maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set up bitmask (initially 0) and hash map with {0: -1}

Process Each Digit

Toggle corresponding bit in mask using XOR operation

Check Same Mask

If current mask seen before, all digits have even frequency

Check 1-Bit Different

Check if any mask differing by 1 bit was seen (one odd digit)

Update Maximum

Calculate substring length and update maximum if needed

Code -

solution.c — C

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

#define HASH_SIZE 2048

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

HashNode* hashTable[HASH_SIZE];

void insertOrUpdate(int mask, int index) {
    int hashKey = mask % HASH_SIZE;
    HashNode* node = hashTable[hashKey];
    
    while (node) {
        if (node->mask == mask) {
            return; // Don't update, keep first occurrence
        }
        node = node->next;
    }
    
    // Insert new node
    HashNode* newNode = (HashNode*)malloc(sizeof(HashNode));
    newNode->mask = mask;
    newNode->index = index;
    newNode->next = hashTable[hashKey];
    hashTable[hashKey] = newNode;
}

int findIndex(int mask) {
    int hashKey = mask % HASH_SIZE;
    HashNode* node = hashTable[hashKey];
    
    while (node) {
        if (node->mask == mask) {
            return node->index;
        }
        node = node->next;
    }
    return -999999; // Not found
}

int longestAwesome(char* s) {
    int n = strlen(s);
    
    // Initialize hash table
    for (int i = 0; i < HASH_SIZE; i++) {
        hashTable[i] = NULL;
    }
    
    insertOrUpdate(0, -1); // Empty prefix has mask 0 at index -1
    int mask = 0;
    int maxLen = 1;
    
    for (int i = 0; i < n; i++) {
        int digit = s[i] - '0';
        // Toggle bit for current digit
        mask ^= 1 << digit;
        
        // Case 1: Current mask seen before
        int firstIdx = findIndex(mask);
        if (firstIdx != -999999) {
            int len = i - firstIdx;
            if (len > maxLen) maxLen = len;
        } else {
            insertOrUpdate(mask, i);
        }
        
        // Case 2: Check masks differing by exactly 1 bit
        for (int j = 0; j < 10; j++) {
            int targetMask = mask ^ (1 << j);
            firstIdx = findIndex(targetMask);
            if (firstIdx != -999999) {
                int len = i - firstIdx;
                if (len > maxLen) maxLen = len;
            }
        }
    }
    
    return maxLen;
}

int main() {
    char s[100001];
    scanf("\"%100000[^\"]\"", s);
    printf("%d\n", longestAwesome(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string, each lookup/insert in hash map is O(1)

✓ Linear Growth

Space Complexity

O(min(n, 2^10))

Hash map stores at most min(n, 1024) different bitmask patterns

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

890 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