Substring XOR Queries - Practice Coding Problems

Substring XOR Queries - Problem

Substring XOR Queries - Find the shortest binary substring that satisfies XOR conditions

You're given a binary string s and an array of queries. Each query contains two integers [first, second].

For each query, you need to find the shortest substring of s whose decimal value, when XORed with first, equals second. In mathematical terms: substring_value ^ first == second.

Goal: Return the start and end indices [left, right] of the shortest valid substring for each query. If no such substring exists, return [-1, -1]. When multiple substrings have the same length, choose the one with the smallest starting index.

Example: If s = "101101" and query is [4, 5], we need to find a substring whose decimal value XORed with 4 gives 5. Since 4 ^ 5 = 1, we're looking for a substring with decimal value 1, which is "1" at index 0.

Input & Output

example_1.py — Basic Case

$ Input: s = "101101", queries = [[4,5]]

› Output: [[0,0]]

💡 Note: For query [4,5], we need to find substring whose value XORed with 4 equals 5. Since 4 ^ 5 = 1, we need substring with decimal value 1. The substring "1" at index [0,0] has decimal value 1.

example_2.py — Multiple Queries

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

› Output: [[0,2],[2,3]]

💡 Note: For [0,5]: target = 0^5 = 5, found "101" at [0,2]. For [1,2]: target = 1^2 = 3, found "11" at [2,3].

example_3.py — No Solution

$ Input: s = "101", queries = [[5,1]]

› Output: [[-1,-1]]

💡 Note: For query [5,1], target = 5^1 = 4. No substring in "101" has decimal value 4, so return [-1,-1].

Visualization

Tap to expand

Understanding the Visualization

Index Building

Scan through the binary code book and catalog every possible sequence with its shortest occurrence

Query Processing

For each decoding request, calculate what code value would produce the desired result

Instant Lookup

Use your pre-built index to instantly find the shortest sequence with the target value

Result Delivery

Return the position of the shortest matching sequence, or indicate if impossible

Key Takeaway

🎯 Key Insight: By preprocessing all substring values into a hash map and using XOR's inverse property (A ^ B = C ⟹ A ^ C = B), we can answer each query in O(1) time after O(n²) preprocessing!

Time & Space Complexity

Time Complexity

⏱️

O(n² + q)

O(n²) to preprocess all substrings and build hash map, then O(1) per query for q queries

⚠ Quadratic Growth

Space Complexity

O(n²)

Hash map can store up to O(n²) different substring values in worst case

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 10⁴
s consists only of '0' and '1'
1 ≤ queries.length ≤ 10⁵
0 ≤ first_i, second_i ≤ 10⁹
Important: Substring values can be very large, handle overflow carefully

Asked in

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

The optimal solution uses hash map preprocessing to achieve O(n² + q) time complexity. We first build a hash map containing all possible substring values (up to 30 bits to avoid overflow) and their shortest occurrence positions. Then each query can be answered in O(1) time by computing the target value first ^ second and looking it up in our hash map.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map Preprocessing (Optimal)	O(n² + q)	O(n²)	Preprocess all substrings into a hash map, then answer queries in O(1)
Brute Force (Generate All Substrings)	O(n³ + n²q)	O(1)	Generate all possible substrings and check each one against all queries

Hash Map Preprocessing (Optimal) — Algorithm Steps

Create a hash map to store decimal values and their shortest substring positions
Iterate through all possible substrings of reasonable length (≤30 bits)
For each substring, convert to decimal and update hash map if shorter
For each query, calculate target = first ^ second
Look up target in hash map and return stored indices

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Map

Process all substrings and store shortest occurrence of each value

Calculate Target

For each query, compute target = first ^ second

Hash Map Lookup

Look up the target value in our preprocessed hash map

Return Result

Return stored indices or [-1, -1] if not found

Code -

solution.c — C

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

#define HASH_SIZE 100003

typedef struct HashNode {
    int key;
    int left, right;
    struct HashNode* next;
} HashNode;

typedef struct {
    HashNode* buckets[HASH_SIZE];
} HashMap;

int hash(int key) {
    return abs(key) % HASH_SIZE;
}

void insertHash(HashMap* map, int key, int left, int right) {
    int idx = hash(key);
    HashNode* node = map->buckets[idx];
    
    while (node) {
        if (node->key == key) return;  // Already exists
        node = node->next;
    }
    
    node = (HashNode*)malloc(sizeof(HashNode));
    node->key = key;
    node->left = left;
    node->right = right;
    node->next = map->buckets[idx];
    map->buckets[idx] = node;
}

HashNode* findHash(HashMap* map, int key) {
    int idx = hash(key);
    HashNode* node = map->buckets[idx];
    
    while (node) {
        if (node->key == key) return node;
        node = node->next;
    }
    
    return NULL;
}

int** substringXorQueries(char* s, int** queries, int queriesSize, int* queriesColSize, int* returnSize, int** returnColumnSizes) {
    HashMap map = {0};
    int n = strlen(s);
    
    for (int i = 0; i < n; i++) {
        if (s[i] == '0') {
            if (!findHash(&map, 0)) {
                insertHash(&map, 0, i, i);
            }
            continue;
        }
        
        long long currentVal = 0;
        for (int j = i; j < (i + 30 < n ? i + 30 : n); j++) {
            currentVal = currentVal * 2 + (s[j] - '0');
            
            if (currentVal > 2147483647) break;
            
            int val = (int) currentVal;
            if (!findHash(&map, val)) {
                insertHash(&map, val, i, j);
            }
        }
    }
    
    int** result = (int**)malloc(queriesSize * sizeof(int*));
    *returnSize = queriesSize;
    *returnColumnSizes = (int*)malloc(queriesSize * sizeof(int));
    
    for (int q = 0; q < queriesSize; q++) {
        (*returnColumnSizes)[q] = 2;
        result[q] = (int*)malloc(2 * sizeof(int));
        
        int target = queries[q][0] ^ queries[q][1];
        HashNode* node = findHash(&map, target);
        
        if (node) {
            result[q][0] = node->left;
            result[q][1] = node->right;
        } else {
            result[q][0] = -1;
            result[q][1] = -1;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² + q)

O(n²) to preprocess all substrings and build hash map, then O(1) per query for q queries

⚠ Quadratic Growth

Space Complexity

O(n²)

Hash map can store up to O(n²) different substring values in worst case

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 10⁴
s consists only of '0' and '1'
1 ≤ queries.length ≤ 10⁵
0 ≤ first_i, second_i ≤ 10⁹
Important: Substring values can be very large, handle overflow carefully

28.5K Views

Medium Frequency

~25 min Avg. Time

847 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

Hash Map Preprocessing (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler