1class Solution {
2    public int[] sortByReflection(int[] nums) {
3        int n = nums.length;
4
5        // Use a boxed Integer array so we can supply a custom Comparator
6        Integer[] boxed = new Integer[n];
7        Arrays.setAll(boxed, i -> nums[i]);
8
9        // Sort by the bit-reversed value first; if equal, sort by the original value
10        Arrays.sort(boxed, (first, second) -> {
11            int reflectedFirst = f(first);
12            int reflectedSecond = f(second);
13            if (reflectedFirst != reflectedSecond) {
14                return Integer.compare(reflectedFirst, reflectedSecond);
15            }
16            return Integer.compare(first, second);
17        });
18
19        // Copy the sorted boxed values back into the primitive result array
20        for (int i = 0; i < n; i++) {
21            nums[i] = boxed[i];
22        }
23        return nums;
24    }
25
26    /**
27     * Reflects (reverses) the significant bits of the given value.
28     * It reads bits from least-significant to most-significant and
29     * rebuilds them in reverse order, stopping at the highest set bit.
30     *
31     * Example: 6 (110) -> 3 (011)
32     *
33     * @param value the input integer
34     * @return the value formed by reversing its significant bits
35     */
36    private int f(int value) {
37        int reflected = 0;
38        while (value != 0) {
39            // Shift the result left and append the current lowest bit of value
40            reflected = (reflected << 1) | (value & 1);
41            // Drop the lowest bit of value
42            value >>= 1;
43        }
44        return reflected;
45    }
46}
47

1class Solution {
2public:
3    vector<int> sortByReflection(vector<int>& nums) {
4        // Reflect (reverse) the bits of 'value' up to its highest set bit.
5        // Example: 6 (110) -> 3 (011); 4 (100) -> 1 (001).
6        auto reflectBits = [](int value) {
7            int reflected = 0;
8            while (value) {
9                // Shift the result left and append the current lowest bit.
10                reflected = (reflected << 1) | (value & 1);
11                value >>= 1;
12            }
13            return reflected;
14        };
15
16        // Sort by the bit-reflected value in ascending order.
17        // When two reflected values are equal, fall back to comparing
18        // the original values to keep the ordering deterministic.
19        sort(nums.begin(), nums.end(), [&](int lhs, int rhs) {
20            int reflectedLhs = reflectBits(lhs);
21            int reflectedRhs = reflectBits(rhs);
22            if (reflectedLhs != reflectedRhs) {
23                return reflectedLhs < reflectedRhs;
24            }
25            return lhs < rhs;
26        });
27
28        return nums;
29    }
30};
31

1/**
2 * Sorts the array based on the "reflection" (bit reversal) of each number.
3 * Numbers are ordered primarily by their reflected bit pattern,
4 * and ties are broken by the original numeric value.
5 *
6 * @param nums - The array of non-negative integers to sort.
7 * @returns The array sorted by reflection value, then by original value.
8 */
9function sortByReflection(nums: number[]): number[] {
10    /**
11     * Computes the reflection of a number by reversing the order
12     * of its significant bits (from the most significant set bit downward).
13     *
14     * @param value - The number whose bits are to be reversed.
15     * @returns The integer formed by reversing the significant bits.
16     */
17    const reflect = (value: number): number => {
18        let reflected = 0;
19        // Process each bit from least significant to most significant.
20        for (; value; value >>= 1) {
21            // Shift the result left and append the current lowest bit.
22            reflected = (reflected << 1) | (value & 1);
23        }
24        return reflected;
25    };
26
27    nums.sort((a: number, b: number): number => {
28        const reflectA = reflect(a);
29        const reflectB = reflect(b);
30        // Primary comparison: by reflected bit value.
31        if (reflectA !== reflectB) {
32            return reflectA - reflectB;
33        }
34        // Secondary comparison: by original value to break ties.
35        return a - b;
36    });
37
38    return nums;
39}
40