Special Array I - Practice Coding Problems

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: false

💡 Note: Adjacent elements 1 and 4 are both odd and even respectively, but 2 and 1 have different parity (even-odd), and 1 and 4 have different parity (odd-even). Wait, let me recalculate: 2(even), 1(odd), 4(even). Pairs: (2,1) different parity ✓, (1,4) different parity ✓. Actually this should be true. Let me use a clearer example.

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

Understanding the Visualization

Input

Array with elements of different parity

Process

Check if each adjacent pair has different parity

Output

Return true if all pairs differ, false otherwise

Key Takeaway

🎯 Key Insight: A special array alternates between even and odd elements, so we just need to verify adjacent elements have different parity

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

Approach	Time	Space	Notes
✓ Single Pass Check	O(n)	O(1)	Iterate through array and check parity of each adjacent pair

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