Find if Array Can Be Sorted - Practice Coding Problems

Find if Array Can Be Sorted - Problem

Can you sort by bit count? You're given an array of positive integers, and you have a special sorting power: you can swap any two adjacent elements if they have the same number of set bits (1s in their binary representation).

Your mission is to determine if you can use this power to sort the entire array in ascending order. You can perform as many swaps as needed, but remember - only adjacent elements with the same bit count can be swapped!

For example, numbers 3 (binary: 11) and 6 (binary: 110) both have 2 set bits, so they can be swapped if they're adjacent. But 3 and 4 (binary: 100) cannot be swapped since they have different bit counts (2 vs 1).

Input & Output

example_1.py — Basic Sortable Case

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

› Output: true

💡 Note: We can sort this array by swapping adjacent elements with the same bit count. 8,4,2,1 all have 1 set bit and can be rearranged among themselves. 3,5 have 2 set bits and can be rearranged. Final order: [1,2,3,4,5,8] is achievable.

example_2.py — Non-Sortable Case

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

› Output: false

💡 Note: Looking at bit counts: 1(1bit), 2(1bit), 3(2bits), 4(1bit), 5(2bits). To be sorted, we need 3 to come before 4, but they have different bit counts and can never be swapped. The array cannot be sorted.

example_3.py — Single Element

$ Input: [1]

› Output: true

💡 Note: A single element array is always sorted, regardless of bit counts.

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 2⁸
All integers in nums are positive

Visualization

Tap to expand

Understanding the Visualization

Identify Bit Groups

Count set bits for each number - this determines their 'color'

Group Elements

Organize elements into groups by bit count - same color balls together

Sort Within Groups

Sort each color group individually - these represent possible arrangements

Verify Global Order

Check if the group arrangement can produce the target sorted sequence

Key Takeaway

🎯 Key Insight: Elements can only move within their bit-count groups, so we verify if each group can supply the right elements in the right order for the sorted sequence

Asked in

⊞ Microsoft 35 a Amazon 28 G Google 22 f Meta 15

The key insight is that elements can only be rearranged within groups of the same bit count. The optimal approach groups elements by their bit counts, sorts each group internally, then verifies if this arrangement matches the target sorted order. Time complexity: O(n log n) for the grouping approach.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation Approach	O(n²)	O(1)	Repeatedly try to swap adjacent elements with same bit counts until no more swaps are possible
Group Analysis Approach	O(n log n)	O(n)	Group elements by bit count, then verify if each group can be sorted to match target positions

Simulation Approach — Algorithm Steps

Count set bits for each number using bit manipulation
Repeatedly scan array for adjacent elements with same bit count that are out of order
Swap such pairs and mark that a swap was made
Continue until no swaps are made in a complete pass
Check if final array is sorted

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Array

Start with unsorted array, calculate bit count for each element

Find Swappable Pair

Look for adjacent elements with same bit count that are out of order

Perform Swap

Swap the elements and continue scanning

Repeat Process

Continue until no more swaps are possible

Check Result

Verify if final array matches the sorted order

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.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 canSortArray(int* nums, int n) {
    int* arr = (int*)malloc(n * sizeof(int));
    memcpy(arr, nums, n * sizeof(int));
    
    // Keep swapping until no more swaps possible
    bool changed = true;
    while (changed) {
        changed = false;
        for (int i = 0; i < n - 1; i++) {
            // If adjacent elements have same bit count and are out of order
            if (countBits(arr[i]) == countBits(arr[i + 1]) && 
                arr[i] > arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
                changed = true;
            }
        }
    }
    
    // Check if array is sorted
    int* sorted = (int*)malloc(n * sizeof(int));
    memcpy(sorted, nums, n * sizeof(int));
    qsort(sorted, n, sizeof(int), compare);
    
    bool result = true;
    for (int i = 0; i < n; i++) {
        if (arr[i] != sorted[i]) {
            result = false;
            break;
        }
    }
    
    free(arr);
    free(sorted);
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse input array
    int nums[100];
    int n = 0;
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%s\n", canSortArray(nums, n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we may need O(n) passes through the array, each taking O(n) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables and bit counting

✓ Linear Space

28.5K Views

Medium Frequency

~18 min Avg. Time

847 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

Simulation Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler