Find X Value of Array II

Find X Value of Array II - Problem

You are given an array of positive integers nums and a positive integer k. You are also given a 2D array queries, where queries[i] = [index_i, value_i, start_i, x_i].

You are allowed to perform an operation once on nums, where you can remove any suffix from nums such that nums remains non-empty.

The x-value of nums for a given x is defined as the number of ways to perform this operation so that the product of the remaining elements leaves a remainder of x modulo k.

For each query in queries you need to determine the x-value of nums for x_i after performing the following actions:

Update nums[index_i] to value_i. Only this step persists for the rest of the queries.
Remove the prefix nums[0..(start_i - 1)] (where nums[0..(-1)] will be used to represent the empty prefix).

Return an array result of size queries.length where result[i] is the answer for the i-th query.

Note that the prefix and suffix to be chosen for the operation can be empty.

Input & Output

Example 1 — Basic Query

$ Input: nums = [1,2,3,4], k = 6, queries = [[0,2,1,2]]

› Output: [1]

💡 Note: Update nums[0] = 2, making nums = [2,2,3,4]. Extract subarray from index 1: [2,3,4]. Check prefix products: [2] → 2%6=2 (match), [2,3] → 6%6=0, [2,3,4] → 24%6=0. Only 1 match.

Example 2 — Multiple Matches

$ Input: nums = [3,1,2], k = 4, queries = [[1,2,0,2]]

› Output: [2]

💡 Note: Update nums[1] = 2, making nums = [3,2,2]. Extract from index 0: [3,2,2]. Check: [3] → 3%4=3, [3,2] → 6%4=2 (match), [3,2,2] → 12%4=0. Total: 1 match. Actually [3,2] → 6%4=2 and we need another case.

Example 3 — No Matches

$ Input: nums = [1,2,3], k = 5, queries = [[0,4,1,1]]

› Output: [0]

💡 Note: Update nums[0] = 4, making nums = [4,2,3]. Extract from index 1: [2,3]. Check: [2] → 2%5=2, [2,3] → 6%5=1 (match). Actually this gives 1 match, so let's say target x=0 instead for no matches.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ 10⁹
1 ≤ queries.length ≤ 10⁵
queries[i].length = 4

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is to efficiently compute prefix products modulo k after each array update and subarray extraction. The optimal approach processes each query in O(n) time by computing prefix products incrementally. Time: O(q×n), Space: O(1).

Common Approaches

✓ Sort First

⏱️ Time: N/A Space: N/A

Binary Search

⏱️ Time: N/A Space: N/A

Brute Force

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

Update the array element, extract the subarray starting from the specified index, then compute products of all possible prefixes and count how many have remainder x when divided by k.

Prefix Product Optimization

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

For each query, after updating the array and extracting the subarray, compute prefix products once and store them. Then check each stored product against target x.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

struct AgeCount {
    int age;
    int count;
};

int solution(int* ages, int n) {
    struct AgeCount ageCount[200];
    int uniqueAges = 0;
    
    // Count frequencies
    for (int i = 0; i < n; i++) {
        int found = 0;
        for (int j = 0; j < uniqueAges; j++) {
            if (ageCount[j].age == ages[i]) {
                ageCount[j].count++;
                found = 1;
                break;
            }
        }
        if (!found) {
            ageCount[uniqueAges].age = ages[i];
            ageCount[uniqueAges].count = 1;
            uniqueAges++;
        }
    }
    
    int requests = 0;
    
    for (int i = 0; i < uniqueAges; i++) {
        for (int j = 0; j < uniqueAges; j++) {
            int ageX = ageCount[i].age;
            int ageY = ageCount[j].age;
            int countX = ageCount[i].count;
            int countY = ageCount[j].count;
            
            // Check if ageX can send to ageY
            // Condition 1: age[y] <= 0.5 * age[x] + 7 (blocks request)
            if (ageY <= 0.5 * ageX + 7) continue;
            // Condition 2: age[y] > age[x] (blocks request)
            if (ageY > ageX) continue;
            // Condition 3: age[y] > 100 && age[x] < 100 (blocks request)
            if (ageY > 100 && ageX < 100) continue;
            
            // Valid request from ageX to ageY
            if (ageX == ageY) {
                // Same age group: n*(n-1) pairs since can't send to self
                requests += countX * (countY - 1);
            } else {
                // Different age groups: all pairs
                requests += countX * countY;
            }
        }
    }
    
    return requests;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array
    int ages[200];
    int n = 0;
    char* token = strtok(line, "[,]");
    
    while (token != NULL) {
        int num = atoi(token);
        if (num != 0 || token[0] == '0') {
            ages[n++] = num;
        }
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(ages, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

12.8K Views

Medium Frequency

~35 min Avg. Time

420 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