Sort Integers by The Number of 1 Bits - Practice Coding Problems

Sort Integers by The Number of 1 Bits - Problem

Imagine you have an array of integers, and you need to sort them in a unique way! Instead of sorting by their actual values, you need to sort them by how many 1's appear in their binary representation.

Here's the twist: when two numbers have the same number of 1-bits, you should sort them in ascending numerical order as a tiebreaker.

For example, the number 7 in binary is 111 (three 1's), while 4 in binary is 100 (one 1). So 4 should come before 7 in our special sorting.

Goal: Return the array sorted by the count of 1-bits in each number's binary representation, with numerical order as the tiebreaker.

Input & Output

example_1.py — Basic sorting

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

› Output: [0,1,2,4,8,3,5,6,7]

💡 Note: 0(0 bits), 1(1 bit), 2(1 bit), 4(1 bit), 8(1 bit) come first. Then 3(2 bits), 5(2 bits), 6(2 bits), and finally 7(3 bits). Within each group, numbers are sorted in ascending order.

example_2.py — Mixed values

$ Input: [1024,512,256,128,64,32,16,8,4,2,1]

› Output: [1,2,4,8,16,32,64,128,256,512,1024]

💡 Note: All powers of 2 have exactly 1 bit set in their binary representation, so they are sorted by their actual values in ascending order.

example_3.py — Same bit counts

$ Input: [10,100,1000,10000]

› Output: [10,100,1000,10000]

💡 Note: 10(2 bits: 1010), 100(3 bits: 1100100), 1000(4 bits: 1111101000), 10000(5 bits: 10011100010000). Each has different bit counts, so original order is maintained within each group.

Constraints

1 ≤ arr.length ≤ 500
0 ≤ arr[i] ≤ 10⁴
Follow up: Can you solve this in O(n log n) time complexity?

Visualization

Tap to expand

Understanding the Visualization

Convert to Binary

Each number shows its binary representation and bit count

Group by Bit Count

Numbers are grouped by their 1-bit count

Sort Within Groups

Within each group, sort by numerical value

Final Arrangement

Combine groups in ascending order of bit counts

Key Takeaway

🎯 Key Insight: Use a tuple `(bit_count, value)` as the sorting key to handle primary sorting by bit count and automatic tie-breaking by value!

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses built-in sorting with a custom comparator that compares elements by their bit count first, then by value. This achieves O(n log n) time complexity with minimal space overhead, leveraging efficient built-in bit counting functions like __builtin_popcount() in C++ or bin().count('1') in Python.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Manual Bit Counting & Comparison)	O(n² * log(max_val))	O(1)	Count bits manually and use bubble sort with custom comparison
One-Pass Optimal Solution	O(n log n * log(max_val))	O(log n)	Sort with custom comparator that computes bit counts on-the-fly
Two-Pass with Precomputed Bit Counts	O(n log n + n * log(max_val))	O(n)	First pass: compute all bit counts, Second pass: sort using precomputed values

Brute Force (Manual Bit Counting & Comparison) — Algorithm Steps

Create a helper function to count 1-bits by repeatedly dividing by 2
Implement bubble sort with custom comparison
For each pair, compare bit counts first, then values for ties
Repeat until no more swaps are needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Bits

Count 1-bits in each number manually

Compare Adjacent

Compare bit counts, use value for ties

Bubble Up

Larger bit counts bubble to the right

Repeat

Continue until no swaps needed

Code -

solution.c — C

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

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

void sortByBits(int* arr, int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            int bitsJ = countBits(arr[j]);
            int bitsJ1 = countBits(arr[j + 1]);
            
            if (bitsJ > bitsJ1 || (bitsJ == bitsJ1 && arr[j] > arr[j + 1])) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
    int n = 9;
    sortByBits(arr, n);
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² * log(max_val))

O(n²) for bubble sort, O(log(max_val)) for counting bits in each comparison

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few extra variables for swapping and bit counting

✓ Linear Space

98.4K Views

Medium Frequency

~12 min Avg. Time

2.2K 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

Brute Force (Manual Bit Counting & Comparison) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler