Code Logo

Parity Flag Map

Published at05 Jan 2026
Created by
Array Manipulation Easy 8 views
Like7

This one is about reading carefully and then following a clear rule. In Parity Flag Map, you are trying to work toward the right list by following one clear idea.

Here, you start with one piece of information and turn it into something cleaner or more useful. You might keep only certain items, change their shape, or fix how text looks. The important part is to follow the steps in the right order. If you do that carefully, the final result comes out just the way the problem expects.

For example, if the input is nums = [1,3,5], the answer is [false,false,false]. All numbers are odd. Another example is nums = [], which gives []. No readings mean no flags.

This is a friendly practice problem, but it still rewards careful reading. The key is doing the steps in the right order and not changing things you should keep.

Example Input & Output

Example 1
Input
nums = [1,3,5]
Output
[false,false,false]
Explanation

All numbers are odd.

Example 2
Input
nums = []
Output
[]
Explanation

No readings mean no flags.

Example 3
Input
nums = [2,5,6,3]
Output
[true,false,true,false]
Explanation

Even numbers (2,6) produce true entries.

Algorithm Flow

Recommendation Algorithm Flow for Parity Flag Map

Solution Approach

A clean way to solve Parity Flag Map is to turn each number into a boolean that tells whether it is even. Because the output is exactly one boolean per input number, the most natural and readable approach is to build the result array while walking through the input.

The benefit of this method is that it is simple and easy to reason about. We visit each element exactly once, so it runs in linear time, and we only need one boolean per number for the output.

We start by creating an empty result array and looping over the input:

function parity_flags(nums) {
    var r = [];
    for (var i = 0; i < nums.length; i++) r.push(nums[i] % 2 === 0);
    return r;
}

The key line is nums[i] % 2 === 0. The modulo operator returns the remainder of dividing the number by 2. If the remainder is 0, the number is even, so the expression is true. Otherwise it is odd and becomes false. We push that boolean onto the result array for each element.

Let us trace the example nums = [1, 3, 5]. Every value is odd, so each comparison returns false, producing [false, false, false]. For an empty array, the loop never runs and we return an empty array, which matches the expected [].

Negative and zero values also work correctly, because 0 % 2 and -2 % 2 are both 0, so they are flagged as even.

The time complexity is O(n) since we visit each element once, and the space complexity is O(n) because we build a result array of the same size.

Best Answers

java
class Solution {
    public boolean[] parity_flags(int[] nums) {
        boolean[] r = new boolean[nums.length];
        for (int i = 0; i < nums.length; i++) r[i] = nums[i] % 2 == 0;
        return r;
    }
}