Special Array II - Practice Coding Problems

Special Array II - Problem

An array is considered special if every pair of adjacent elements has different parity (one even, one odd). You're given an array of integers nums and a 2D array queries, where each query [from_i, to_i] asks you to check if the subarray nums[from_i..to_i] is special.

Goal: Return a boolean array where each element indicates whether the corresponding query subarray is special.

Example: Array [4, 3, 1, 6] is special because: 4(even)→3(odd)→1(odd)→6(even) has alternating parity, but [2, 4, 6] is not special because all elements are even.

Input & Output

example_1.py — Basic Special Array

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

› Output: [false]

💡 Note: The subarray is [3,4,1,2,6]. Between 1 and 2 there are two consecutive numbers with the same parity (both odd), so this subarray is not special.

example_2.py — Mixed Queries

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

› Output: [false, true]

💡 Note: Query [0,2]: subarray [4,3,1] has consecutive elements 3,1 (both odd), so not special. Query [2,3]: subarray [1,6] has different parity (odd,even), so special.

example_3.py — Single Element

$ Input: nums = [1], queries = [[0,0]]

› Output: [true]

💡 Note: Single element arrays are always special since there are no adjacent pairs to check.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
1 ≤ queries.length ≤ 10⁵
0 ≤ queries[i][0] ≤ queries[i][1] ≤ nums.length - 1

Visualization

Tap to expand

Understanding the Visualization

Identify Violations

Mark all positions where adjacent dancers have the same role (both lead or both follow)

Build Prefix Sum

Count cumulative violations from start to each position

Answer Queries

For any dance sequence range, check if violation count is zero using prefix sum difference

Key Takeaway

🎯 Key Insight: By precomputing a prefix sum of violations, we transform O(n) range checks into O(1) lookups, making the solution optimal for multiple queries.

Asked in

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

The optimal solution uses a prefix sum approach to achieve O(1) query time. First, we identify all violation positions where adjacent elements have the same parity. Then we build a prefix sum array counting violations up to each index. For any query range, we can instantly determine if violations exist by checking the prefix sum difference.

Common Approaches

Approach	Time	Space	Notes
✓ Prefix Sum Array (Optimal)	O(n + m)	O(n)	Precompute prefix sum of violations for O(1) query answering
Prefix Sum with Binary Search	O(n + m log n)	O(n)	Precompute violation positions and use binary search for range queries

Prefix Sum Array (Optimal) — Algorithm Steps

Create violation array: mark 1 where adjacent elements have same parity, 0 otherwise
Build prefix sum array from violation array
For each query [from, to], check if prefixSum[to-1] - prefixSum[from-1] == 0
Return true if no violations in range, false otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Mark Violations

Create array marking where adjacent elements have same parity

Build Prefix Sum

Accumulate violation counts from left to right

Answer Queries

Use prefix sum difference to check violations in any range instantly

Code -

solution.c — C

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

bool* isArraySpecial(int* nums, int numsSize, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    *returnSize = queriesSize;
    bool* result = (bool*)malloc(queriesSize * sizeof(bool));
    
    if (numsSize <= 1) {
        for (int i = 0; i < queriesSize; i++) {
            result[i] = true;
        }
        return result;
    }
    
    // Build prefix sum of violations
    int* prefixViolations = (int*)calloc(numsSize, sizeof(int));
    int violationCount = 0;
    
    for (int i = 0; i < numsSize - 1; i++) {
        if ((nums[i] % 2) == (nums[i + 1] % 2)) {
            violationCount++;
        }
        prefixViolations[i + 1] = violationCount;
    }
    
    for (int q = 0; q < queriesSize; q++) {
        int from = queries[q][0];
        int to = queries[q][1];
        int violationsInRange = prefixViolations[to] - prefixViolations[from];
        result[q] = violationsInRange == 0;
    }
    
    free(prefixViolations);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

O(n) preprocessing to build prefix sum, O(1) per query, m queries total

✓ Linear Growth

Space Complexity

O(n)

Prefix sum array of size n

⚡ Linearithmic Space

28.9K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Prefix Sum Array (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler