Find X Value of Array I - Practice Coding Problems

Find X Value of Array I - Problem

You are given an array of positive integers nums and a positive integer k. Your task is to find the x-value for each possible remainder x from 0 to k-1.

The x-value represents the number of ways you can remove a prefix and/or suffix from the array such that the product of the remaining elements has remainder x when divided by k.

Key points:

A prefix can be empty or contain elements from the beginning
A suffix can be empty or contain elements from the end
The array must remain non-empty after removal
Prefix and suffix cannot overlap

Return an array result of size k where result[x] is the x-value for remainder x.

Input & Output

example_1.py — Basic Case

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

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

💡 Note: Subarrays: [2]→2%5=2, [2,3]→6%5=1, [2,3,4]→24%5=4, [3]→3%5=3, [3,4]→12%5=2, [4]→4%5=4. Count: remainder 0→0, 1→1, 2→2, 3→1, 4→2

example_2.py — Single Element

$ Input: nums = [7], k = 3

› Output: [0, 1, 0]

💡 Note: Only one subarray [7] with product 7. 7 % 3 = 1, so result[1] = 1, others are 0

example_3.py — All Same Remainder

$ Input: nums = [3, 3], k = 3

› Output: [1, 0, 0]

💡 Note: Subarrays: [3]→3%3=0, [3,3]→9%3=0, [3]→3%3=0. All products have remainder 0, so result[0] = 3

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000
2 ≤ k ≤ 1000
All elements in nums are positive integers

Visualization

Tap to expand

Understanding the Visualization

Setup Factory

Arrange cookies in a line with sweetness values [2, 3, 4, 5]

Make Cuts

Try all possible ways to cut from front and back

Calculate Sweetness

Multiply remaining cookie values to get total sweetness

Find Remainder

Divide total sweetness by k=5 and record remainder

Count Results

Tally how many cuts give each possible remainder (0-4)

Key Takeaway

🎯 Key Insight: By systematically trying all possible cutting patterns (subarrays) and tracking the remainder of each product, we can efficiently count how many ways each remainder can be achieved.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal approach uses nested loops to generate all possible subarrays and count remainder frequencies. For each starting position, maintain a running product to avoid recalculating from scratch. This achieves O(n²) time complexity with O(1) extra space, making it the most practical solution for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ Prefix-Suffix Product Arrays	O(n²)	O(n)	Pre-compute prefix and suffix products, then combine efficiently
Brute Force (Nested Loops)	O(n³)	O(1)	Try all possible prefix and suffix combinations directly

Prefix-Suffix Product Arrays — Algorithm Steps

First pass: Compute prefix products array where prefix[i] = product of nums[0] to nums[i]
Second pass: Compute suffix products array where suffix[i] = product of nums[i] to nums[n-1]
For each valid subarray from i to j, product = prefix[j] / prefix[i-1] (handle edge cases)
Use modular arithmetic throughout to prevent overflow
Count remainders for each possible subarray product

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Prefix

Calculate cumulative products from left

Build Suffix

Calculate cumulative products from right

Combine

Use prefix/suffix to get any subarray product

Count

Count remainders efficiently

Code -

solution.c — C

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

int* solution(int* nums, int numsSize, int k, int* returnSize) {
    *returnSize = k;
    int* result = (int*)calloc(k, sizeof(int));
    
    // For each starting position
    for (int i = 0; i < numsSize; i++) {
        long long product = 1;
        for (int j = i; j < numsSize; j++) {
            product = (product * nums[j]) % k;
            result[product]++;
        }
    }
    
    return result;
}

int main() {
    int nums[1000];
    int numsSize = 0;
    int k;
    
    // Read array
    char line[10000];
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, " ");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    scanf("%d", &k);
    
    int returnSize;
    int* result = solution(nums, numsSize, k, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(", ");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) to build prefix array, O(n) for suffix array, O(n²) to check all subarray combinations

⚠ Quadratic Growth

Space Complexity

O(n)

Space for prefix and suffix arrays of size n each

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~18 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Prefix-Suffix Product Arrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler