Transform Array by Parity - Practice Coding Problems

Transform Array by Parity - Problem

You are given an integer array nums. Transform nums by performing the following operations in the exact order specified:

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.

Input & Output

Example 1 — Basic Case

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

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

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

Example 2 — All Even

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

› Output: [0,0,0]

💡 Note: All numbers are even, so all become 0. Sorted result: [0,0,0]

Example 3 — All Odd

$ Input: nums = [1,3,5]

› Output: [1,1,1]

💡 Note: All numbers are odd, so all become 1. Sorted result: [1,1,1]

Constraints

1 ≤ nums.length ≤ 1000
-1000 ≤ nums[i] ≤ 1000

Visualization

Tap to expand

Understanding the Visualization

Input

Integer array with mixed even/odd values

Transform

Replace even→0, odd→1

Sort

Arrange in non-decreasing order

Key Takeaway

🎯 Key Insight: Since we only get 0s and 1s, counting is more efficient than sorting

Asked in

M Microsoft 25 G Google 20 a Amazon 15

Transform each element to 0 (even) or 1 (odd), then sort. The key insight is that counting approach avoids unnecessary sorting since we only have binary values. Best approach uses frequency counting: Time O(n), Space O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Count-Based Construction	O(n)	O(n)	Count zeros and ones during transformation, then build result array
Direct Transform and Sort	O(n log n)	O(1)	Transform each element to 0 or 1, then sort the entire array

Count-Based Construction — Algorithm Steps

Count even numbers (will become 0s) and odd numbers (will become 1s)
Create result array with count_zeros 0s followed by count_ones 1s
Return the constructed array

Visualization

Tap to expand

Step-by-Step Walkthrough

Count

Count even and odd numbers

Construct

Build array with counted 0s then 1s

Result

Optimally constructed array

Code -

solution.c — C

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

void solution(int* nums, int numsSize, int* result) {
    // Count even and odd numbers
    int evenCount = 0;
    int oddCount = 0;
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] % 2 == 0) {
            evenCount++;
        } else {
            oddCount++;
        }
    }
    
    // Build result array: all 0s first, then all 1s
    int index = 0;
    
    // Fill with 0s
    for (int i = 0; i < evenCount; i++) {
        result[index++] = 0;
    }
    
    // Fill with 1s
    for (int i = 0; i < oddCount; i++) {
        result[index++] = 1;
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse JSON array manually
    int nums[1000];
    int count = 0;
    char *ptr = line + 1; // Skip opening bracket
    char *token = strtok(ptr, ",]");
    while (token != NULL) {
        nums[count++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result[1000];
    solution(nums, count, result);
    
    // Print result in JSON format
    printf("[");
    for (int i = 0; i < count; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count elements, then O(n) to fill result array

✓ Linear Growth

Space Complexity

O(n)

Result array of size n stores the final output

⚡ Linearithmic Space

28.1K Views

Medium Frequency

~15 min Avg. Time

850 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

Count-Based Construction — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler