Find if Array Can Be Sorted - Practice Coding Problems

Find if Array Can Be Sorted - Problem

You are given a 0-indexed array of positive integers nums.

In one operation, you can swap any two adjacent elements if they have the same number of set bits.

You are allowed to do this operation any number of times (including zero).

Return true if you can sort the array in ascending order, else return false.

Input & Output

Example 1 — Basic Sortable Case

$ Input: nums = [8,4,2,30,15]

› Output: true

💡 Note: Elements 8,4,2 have 1 set bit each and can be sorted among themselves. Elements 30,15 have 4 and 4 set bits respectively and can be arranged. The array can become [2,4,8,15,30].

Example 2 — Non-sortable Case

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

› Output: false

💡 Note: Each element has different number of set bits: 1(1), 2(1), 3(2), 4(1), 5(2). Cannot swap 3 and 4 since they have different bit counts, so array cannot be fully sorted.

Example 3 — Already Sorted

$ Input: nums = [3,16,8,4,2]

› Output: false

💡 Note: 16 has 1 set bit, but 3 has 2 set bits. Since they have different bit counts, 16 cannot move to the beginning to achieve sorted order [2,3,4,8,16].

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 2⁸

Visualization

Tap to expand

Understanding the Visualization

Input Analysis

Count set bits for each element: [8→1, 4→1, 2→1, 30→4, 15→4]

Grouping

Group by bit count: Group1=[8,4,2] (1 bit), Group2=[30,15] (4 bits)

Verification

Check if each group can be sorted to match target positions

Key Takeaway

🎯 Key Insight: Elements can only swap with adjacent elements having the same number of set bits, creating sortable groups

Asked in

G Google 12 M Microsoft 8

The key insight is that elements can only be rearranged within groups that share the same number of set bits. Best approach is to analyze consecutive segments of same bit count and verify they can be sorted to match target positions. Time: O(n²), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ Bit Count Grouping	O(n²)	O(n)	Group elements by bit count and check if they can be sorted within constraints
Brute Force Simulation	O(n³)	O(1)	Repeatedly perform all valid adjacent swaps until no more swaps possible

Bit Count Grouping — Algorithm Steps

Create sorted copy of original array
Group elements by bit count
For each position, check if element can reach it via same-bit-count path
Use segment analysis to verify sortability

Visualization

Tap to expand

Step-by-Step Walkthrough

Group by Bits

Identify consecutive segments with same bit count

Sort Segments

Sort each segment independently

Compare

Check if sorted segments match target positions

Code -

solution.c — C

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

int countBits(int n) {
    int count = 0;
    while (n) {
        count += n & 1;
        n >>= 1;
    }
    return count;
}

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

bool solution(int* nums, int numsSize) {
    int* sorted_nums = malloc(numsSize * sizeof(int));
    memcpy(sorted_nums, nums, numsSize * sizeof(int));
    qsort(sorted_nums, numsSize, sizeof(int), compare);
    
    // For each segment of consecutive elements with same bit count,
    // check if they can be arranged correctly
    int i = 0;
    while (i < numsSize) {
        int j = i;
        int bit_count = countBits(nums[i]);
        
        // Find all consecutive elements with same bit count
        while (j < numsSize && countBits(nums[j]) == bit_count) {
            j++;
        }
        
        // Extract this segment and sort it
        int segment_size = j - i;
        int* segment = malloc(segment_size * sizeof(int));
        memcpy(segment, nums + i, segment_size * sizeof(int));
        qsort(segment, segment_size, sizeof(int), compare);
        
        // Check if segment matches target
        for (int k = 0; k < segment_size; k++) {
            if (segment[k] != sorted_nums[i + k]) {
                free(segment);
                free(sorted_nums);
                return false;
            }
        }
        
        free(segment);
        i = j;
    }
    
    free(sorted_nums);
    return true;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    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²)

Need to check reachability for each element, worst case requires O(n) work per element

⚠ Quadratic Growth

Space Complexity

O(n)

Need to store sorted copy and bit count information for each element

⚡ Linearithmic Space

8.5K Views

Medium Frequency

~15 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

Bit Count Grouping — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler