problemeasyalgorithmsleetcode-3467leetcode 3467leetcode3467

Transform Array by Parity

EasyUpdated: Aug 2, 2025
Practice on:
LeetCode

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 numbers with 1.
  3. Sort the modified array in non-decreasing order.

Return the resulting array after performing these operations.

Examples

Example 1

Input: nums = [4,3,2,1]
Output: [0,0,1,1]
Explanation:
* Replace the even numbers (4 and 2) with 0 and the odd numbers (3 and 1) with 1. Now, `nums = [0, 1, 0, 1]`.
* After sorting `nums` in non-descending order, `nums = [0, 0, 1, 1]`.

Example 2

Input: nums = [1,5,1,4,2]
Output: [0,0,1,1,1]
Explanation:
* Replace the even numbers (4 and 2) with 0 and the odd numbers (1, 5 and 1) with 1. Now, `nums = [1, 1, 1, 0, 0]`.
* After sorting `nums` in non-descending order, `nums = [0, 0, 1, 1, 1]`.

Constraints

  • 1 <= nums.length <= 100
  • 1 <= nums[i] <= 1000

Solution

Method 1 – Counting/Sorting

Intuition

Replace even numbers with 0, odd numbers with 1, then sort. This is equivalent to counting the number of even and odd numbers and constructing the result.

Approach

Iterate through the array, replace each number as described, then sort the result.

Code

C++
#include <vector>
#include <algorithm>
using namespace std;
class Solution {
public:
    vector<int> transformArray(vector<int>& nums) {
        for (int& x : nums) x = (x % 2 == 0 ? 0 : 1);
        sort(nums.begin(), nums.end());
        return nums;
    }
};
Java
import java.util.*;
class Solution {
    public int[] transformArray(int[] nums) {
        for (int i = 0; i < nums.length; ++i) {
            nums[i] = (nums[i] % 2 == 0) ? 0 : 1;
        }
        Arrays.sort(nums);
        return nums;
    }
}
Python
from typing import List
class Solution:
    def transformArray(self, nums: List[int]) -> List[int]:
        return sorted(0 if x % 2 == 0 else 1 for x in nums)
Rust
impl Solution {
    pub fn transform_array(mut nums: Vec<i32>) -> Vec<i32> {
        for x in nums.iter_mut() {
            *x = if *x % 2 == 0 { 0 } else { 1 };
        }
        nums.sort();
        nums
    }
}
TypeScript
function transformArray(nums: number[]): number[] {
    return nums.map(x => x % 2 === 0 ? 0 : 1).sort((a, b) => a - b);
}

Complexity

  • ⏰ Time complexity: O(n log n)
  • 🧺 Space complexity: O(n)

Comments