Special Array I

Special Array I - Problem

Array Easy

An array is considered special if the parity of every pair of adjacent elements is different. In other words, one element in each pair must be even, and the other must be odd.

You are given an array of integers nums. Return true if nums is a special array, otherwise, return false.

Input & Output

Example 1 — Special Array

$ Input: nums = [1]

› Output: true

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

Example 2 — Not Special Array

$ Input: nums = [2,1,4]

› Output: true

💡 Note: Elements are 2(even), 1(odd), 4(even). Adjacent pairs (2,1) and (1,4) both have different parity, so the array is special.

Example 3 — Not Special Array

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

› Output: false

💡 Note: Elements are 4(even), 3(odd), 1(odd), 6(even). Adjacent pair (3,1) both have odd parity, so array is not special.

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 100

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that we only need to check if each adjacent pair has different parity (one even, one odd). Best approach is a single pass through the array checking each adjacent pair. Time: O(n), Space: O(1)

Common Approaches

✓ Single Pass Check

⏱️ Time: O(n) Space: O(1)

Go through the array from left to right, checking if each element has different parity (even/odd) than the next element. If any pair has the same parity, return false.

Single Pass Check — Algorithm Steps

Iterate through array from index 0 to n-2
For each pair (nums[i], nums[i+1]), check if they have different parity
Return false if any pair has same parity, true otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin at first element

Check Pairs

Compare parity of each adjacent pair

Result

Return false if same parity found, true otherwise

Code -

solution.c — C

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

bool solution(int* nums, int numsSize) {
    if (numsSize < 2) {
        return true;
    }
    
    for (int i = 0; i < numsSize - 1; i++) {
        // Check if adjacent elements have same parity
        if (nums[i] % 2 == nums[i + 1] % 2) {
            return false;
        }
    }
    
    return true;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int nums[1000];
    int size = 0;
    char* token = strtok(line, "[,]\n");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '[' && token[0] != ']') {
            nums[size++] = atoi(token);
        }
        token = strtok(NULL, "[,]\n");
    }
    
    bool result = solution(nums, size);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop through n-1 elements to check adjacent pairs

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

12.5K Views

Medium Frequency

~8 min Avg. Time

234 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

Single Pass Check — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler