Sort Integers by The Number of 1 Bits - Problem

You are given an integer array arr. Sort the integers in the array in ascending order by the number of 1's in their binary representation.

In case of two or more integers have the same number of 1's, you have to sort them in ascending order by their decimal values.

Return the array after sorting it.

Input & Output

Example 1 — Basic Case

$ Input: arr = [0,1,1,2]

› Output: [0,1,1,2]

💡 Note: 0 has 0 bits, 1 has 1 bit each, 2 has 1 bit. Sorting by bit count: [0] (0 bits), then [1,1,2] (1 bit each, sorted by value)

Example 2 — Multiple Same Bit Counts

$ Input: arr = [1,5,3,7]

› Output: [1,3,5,7]

💡 Note: All have same bit count (1=1 bit, 5=2 bits, 3=2 bits, 7=3 bits). First 1 (1 bit), then 3,5 (2 bits, sorted by value), then 7 (3 bits)

Example 3 — Edge Case with Zero

$ Input: arr = [0,8,4,2,1]

› Output: [0,1,2,4,8]

💡 Note: 0 has 0 bits, 1,2,4,8 each have 1 bit. Result: 0 first, then 1,2,4,8 sorted by value

Constraints

1 ≤ arr.length ≤ 500
0 ≤ arr[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 12 Apple 8

The key insight is to use a custom sorting comparator that first compares by number of 1-bits, then by original value. Best approach uses built-in sort with bit counting functions. Time: O(n log n), Space: O(log n)

Common Approaches

✓ Brute Force with Manual Bit Counting

⏱️ Time: O(n² × log M) Space: O(1)

For each number, manually count the 1-bits by checking each bit position. Then use a simple sorting algorithm like bubble sort to arrange elements based on bit count and value.

Built-in Sort with Custom Comparator

⏱️ Time: O(n log n × log M) Space: O(log n)

Leverage the language's built-in sorting algorithm (typically quicksort or timsort) with a custom comparator. Use bit manipulation tricks like Brian Kernighan's algorithm or built-in popcount for efficient bit counting.

Two-Pass with Precomputed Bit Counts

⏱️ Time: O(n log M + n log n) Space: O(n)

First pass: calculate and store bit counts for all numbers. Second pass: sort using the precomputed bit counts to avoid recalculating during comparisons.

Brute Force with Manual Bit Counting — Algorithm Steps

Step 1: Create function to count 1-bits by checking each bit position
Step 2: Use bubble sort to compare elements based on bit count first, then value
Step 3: Return the sorted array

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Bits

Manually count 1-bits for each number

Bubble Sort

Compare adjacent elements by bit count, then value

Result

Array sorted by bit count, then by value

Code -

solution.c — C

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

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

void solution(int* arr, int size) {
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            int bits1 = countBits(arr[j]);
            int bits2 = countBits(arr[j + 1]);
            if (bits1 > bits2 || (bits1 == bits2 && arr[j] > arr[j + 1])) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int arr[1000];
    int size = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ' ' && token[0] != '\n') {
            arr[size++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    solution(arr, size);
    
    printf("[");
    for (int i = 0; i < size; i++) {
        printf("%d", arr[i]);
        if (i < size - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × log M)

Nested loops for bubble sort O(n²) × bit counting for each comparison O(log M)

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra variables for sorting in place

⚡ Linearithmic Space

64.7K Views

Medium Frequency

~15 min Avg. Time

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

Sort Integers by The Number of 1 Bits - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with Manual Bit Counting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler