Substring XOR Queries

Substring XOR Queries - Problem

You are given a binary string s, and a 2D integer array queries where queries[i] = [first_i, second_i].

For the i^th query, find the shortest substring of s whose decimal value, val, yields second_i when bitwise XORed with first_i. In other words, val ^ first_i == second_i.

The answer to the i^th query is the endpoints (0-indexed) of the substring [left_i, right_i] or [-1, -1] if no such substring exists. If there are multiple answers, choose the one with the minimum left_i.

Return an array ans where ans[i] = [left_i, right_i] is the answer to the i^th query.

A substring is a contiguous non-empty sequence of characters within a string.

Input & Output

Example 1 — Basic Case

$ Input: s = "101101", queries = [[4,7],[2,3]]

› Output: [[0,0],[0,0]]

💡 Note: For query [4,7]: target = 4^7 = 3. Substring "11" at indices [2,3] has decimal value 3, but substring "1" at [0,0] is shorter. For query [2,3]: target = 2^3 = 1. Substring "1" at indices [0,0] has decimal value 1 and is the shortest.

Example 2 — No Solution

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

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

💡 Note: Target = 5^1 = 4. No substring of "0101" has decimal value 4, so return [-1,-1].

Example 3 — Single Character

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

› Output: [[0,0]]

💡 Note: Target = 3^2 = 1. Substring "1" at indices [0,0] has decimal value 1.

Constraints

1 ≤ s.length ≤ 10⁴
s[i] is either '0' or '1'
1 ≤ queries.length ≤ 10⁵
0 ≤ first_i, second_i ≤ 10⁹

Visualization

Tap to expand

Asked in

M Microsoft 15 G Google 12 A Amazon 8

The key insight is to understand that for each query, we need to find a substring whose decimal value XOR with the first parameter equals the second parameter. The target value is first ^ second. The best approach depends on constraints: pre-computing all substring values gives O(1) query time but uses O(n²) space, while optimized brute force with early termination provides good practical performance. Time: O(n² + q) with preprocessing or O(n×q) optimized, Space: O(n²) or O(1).

Common Approaches

✓ Pre-compute All Substrings

⏱️ Time: O(n² + q) Space: O(n²)

First pass: generate all possible substrings and store their decimal values with positions in a hash map. Second pass: for each query, lookup the target value directly.

Optimized with Early Termination

⏱️ Time: O(n × min(n, 30) × q) Space: O(1)

Optimize the brute force approach by limiting substring lengths (since we only need values up to 2^30) and using early termination when substring value exceeds the target.

Brute Force

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

Generate all possible substrings of the binary string, convert each to decimal, check if XOR with query value gives the target, and find the shortest match.

Pre-compute All Substrings — Algorithm Steps

Generate all substrings and compute their decimal values
Store each value with its shortest occurrence in hash map
For each query, lookup target value and return stored position

Visualization

Tap to expand

Step-by-Step Walkthrough

Preprocess

Build hash map of all substring values

Store

Map each value to its shortest occurrence

Query

O(1) lookup for each query

Code -

solution.c — C

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

#define MAX_VALUES 100000

typedef struct {
    int value;
    int start;
    int end;
} ValuePos;

ValuePos valueMap[MAX_VALUES];
int mapSize = 0;

int findValue(int target) {
    for (int i = 0; i < mapSize; i++) {
        if (valueMap[i].value == target) {
            return i;
        }
    }
    return -1;
}

void addValue(int val, int start, int end) {
    int idx = findValue(val);
    if (idx == -1) {
        valueMap[mapSize].value = val;
        valueMap[mapSize].start = start;
        valueMap[mapSize].end = end;
        mapSize++;
    } else if (end - start < valueMap[idx].end - valueMap[idx].start) {
        valueMap[idx].start = start;
        valueMap[idx].end = end;
    }
}

void solution(char* s, int queries[][2], int queryCount, int result[][2]) {
    int n = strlen(s);
    mapSize = 0;
    
    // Precompute all substring values
    for (int i = 0; i < n; i++) {
        long long val = 0;
        for (int j = i; j < n; j++) {
            val = val * 2 + (s[j] - '0');
            if (val <= 1000000 && mapSize < MAX_VALUES) {
                addValue((int)val, i, j);
            }
        }
    }
    
    for (int q = 0; q < queryCount; q++) {
        int target = queries[q][0] ^ queries[q][1];
        int idx = findValue(target);
        if (idx != -1) {
            result[q][0] = valueMap[idx].start;
            result[q][1] = valueMap[idx].end;
        } else {
            result[q][0] = -1;
            result[q][1] = -1;
        }
    }
}

int main() {
    char s[100001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char line[1000000];
    fgets(line, sizeof(line), stdin);
    
    int queries[1000][2];
    int queryCount = 0;
    
    char* ptr = line + 1;
    while (*ptr != ']' && *ptr != '\0') {
        if (*ptr == '[') {
            sscanf(ptr, "[%d,%d]", &queries[queryCount][0], &queries[queryCount][1]);
            queryCount++;
        }
        ptr++;
    }
    
    int result[1000][2];
    solution(s, queries, queryCount, result);
    
    printf("[");
    for (int i = 0; i < queryCount; i++) {
        printf("[%d,%d]", result[i][0], result[i][1]);
        if (i < queryCount - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² + q)

O(n²) to precompute all substrings, O(1) per query for lookup

⚠ Quadratic Growth

Space Complexity

O(n²)

Hash map stores up to O(n²) substring values and positions

⚠ Quadratic Space

8.5K Views

Medium Frequency

~25 min Avg. Time

245 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

Pre-compute All Substrings — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler