Transform Array by Parity - Practice Coding Problems

Transform Array by Parity - Problem

Transform Array by Parity

You are given an integer array nums. Your task is to transform this array through a specific sequence of operations that will convert it into a binary representation based on parity.

Operations to perform (in exact order):
1. Replace each even number with 0
2. Replace each odd number with 1
3. Sort the modified array in non-decreasing order

Return the resulting array after performing these operations.

Example: If nums = [3, 1, 2, 4], after replacing by parity we get [1, 1, 0, 0], and after sorting we get [0, 0, 1, 1].

Input & Output

example_1.py — Basic Case

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

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

💡 Note: 3 (odd) → 1, 1 (odd) → 1, 2 (even) → 0, 4 (even) → 0. After transformation: [1, 1, 0, 0]. After sorting: [0, 0, 1, 1].

example_2.py — All Even Numbers

$ Input: [2, 4, 6, 8]

› Output: [0, 0, 0, 0]

💡 Note: All numbers are even, so they all become 0. The array remains [0, 0, 0, 0] after sorting.

example_3.py — Single Element

$ Input: [5]

› Output: [1]

💡 Note: 5 is odd, so it becomes 1. The result is [1].

Constraints

1 ≤ nums.length ≤ 10⁴
1 ≤ nums[i] ≤ 10³
All elements in nums are positive integers

Visualization

Tap to expand

Understanding the Visualization

Identify Pattern

Recognize that after transformation, we only have 0s and 1s

Count Categories

Count how many even (→0) and odd (→1) numbers we have

Direct Construction

Build the sorted result directly: all 0s first, then all 1s

Key Takeaway

🎯 Key Insight: Since the result only contains 0s and 1s, we can skip the transformation and sorting steps entirely by counting the frequencies and constructing the sorted result directly!

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a counting approach that recognizes the binary nature of the result. Instead of transforming and sorting, we count how many even numbers exist, then construct the result with that many 0s followed by 1s. This achieves O(n) time complexity and avoids unnecessary operations.

Common Approaches

Approach	Time	Space	Notes
✓ Direct Approach (Transform + Built-in Sort)	O(n log n)	O(1)	Transform elements and use built-in sorting
Optimal Counting Approach	O(n)	O(1)	Count evens and odds, then construct result directly

Direct Approach (Transform + Built-in Sort) — Algorithm Steps

Iterate through the array once to transform elements
Replace each even number with 0 and odd number with 1
Use built-in sort function to sort the transformed array
Return the sorted result

Visualization

Tap to expand

Step-by-Step Walkthrough

Transform

Convert each element to its parity value

Sort

Use built-in sorting algorithm for efficiency

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int* sortArrayByParity(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    
    // Transform: even -> 0, odd -> 1
    for (int i = 0; i < numsSize; i++) {
        nums[i] = nums[i] % 2;
    }
    
    // Sort using built-in function
    qsort(nums, numsSize, sizeof(int), compare);
    
    return nums;
}

int main() {
    int nums[] = {3, 1, 2, 4};
    int size = 4;
    int returnSize;
    int* result = sortArrayByParity(nums, size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) for transformation + O(n log n) for sorting

⚡ Linearithmic

Space Complexity

O(1)

In-place transformation and sorting (excluding recursion stack)

✓ Linear Space

28.7K Views

Medium Frequency

~15 min Avg. Time

892 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

Direct Approach (Transform + Built-in Sort) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler