Special Array I - Practice Coding Problems

Special Array I - Problem

Array Easy

An array is considered special if every pair of adjacent elements has different parity - meaning one element must be even and the other must be odd.

Given an array of integers nums, your task is to determine whether it forms a special array. Return true if the array is special, otherwise return false.

What makes an array special?

Each adjacent pair (nums[i], nums[i+1]) must have different parity
If one element is even, its neighbor must be odd
The pattern can be either even-odd-even-odd... or odd-even-odd-even...

Example: [1, 2, 3, 4] is special because: 1(odd)-2(even)-3(odd)-4(even)

Input & Output

example_1.py — Basic Special Array

$ Input: [1]

› Output: true

💡 Note: Single element arrays are always special by definition since there are no adjacent pairs to violate the rule.

example_2.py — Alternating Pattern

$ Input: [2, 1, 4]

› Output: true

💡 Note: Array follows even-odd-even pattern: 2(even) ≠ 1(odd) ≠ 4(even). All adjacent pairs have different parity.

example_3.py — Same Parity Violation

$ Input: [4, 3, 1, 6]

› Output: false

💡 Note: Elements 3 and 1 are both odd, violating the special array rule. Adjacent elements must have different parity.

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 100
Note: Arrays with 0 or 1 elements are considered special

Visualization

Tap to expand

Understanding the Visualization

Identify Pattern

Special arrays alternate between odd and even numbers

Single Pass Check

Walk through array once, checking each adjacent pair

Early Termination

Return false immediately when same parity is found

Key Takeaway

🎯 Key Insight: A special array is like a perfect checkerboard - adjacent elements must always have different parity (odd/even). One linear pass is sufficient to validate this property.

Asked in

f Meta 25 G Google 18 a Amazon 15 ⊞ Microsoft 12

The optimal solution uses a single pass through the array, checking each adjacent pair for different parity in O(n) time. The key insight is that we can return false immediately upon finding the first pair with the same parity, making this approach both time and space efficient.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check all pairs multiple times with nested iterations
Single Pass Validation (Optimal)	O(n)	O(1)	Check adjacent pairs in one linear pass through the array

Brute Force (Nested Loops) — Algorithm Steps

For each position i in the array
For each adjacent pair starting at i
Check if nums[i] and nums[i+1] have different parity
If any pair has same parity, return false
If all pairs pass, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Multiple Passes

Algorithm makes multiple passes through the array

Redundant Checks

Same pairs are checked multiple times

Inefficient

Much more work than necessary

Code -

solution.c — C

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

bool isArraySpecial(int* nums, int n) {
    if (n <= 1) return true;
    
    // Brute force: check all pairs multiple times
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n - 1; j++) {
            // Check if adjacent elements have same parity
            if (nums[j] % 2 == nums[j + 1] % 2) {
                return false;
            }
        }
    }
    return true;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    while (scanf("%d%c", &nums[n], &c)) {
        n++;
        if (c == ']') break;
    }
    printf("%s\n", isArraySpecial(nums, n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops checking each pair multiple times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

35.0K Views

Medium Frequency

~8 min Avg. Time

1.5K 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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler