2026-04-20：二进制反射排序。用go语言，把数组里每个数先转成二进制；对它的二进制表示做“二进制反射”（把二进制位从左到右反过来，前

package main

import (
    "cmp"
    "fmt"
    "math/bits"
    "slices"
)

func sortByReflection(nums []int) []int {
    slices.SortFunc(nums, func(a, b int)int {
        revA := int(bits.Reverse(uint(a)) >> bits.LeadingZeros(uint(a)))
        revB := int(bits.Reverse(uint(b)) >> bits.LeadingZeros(uint(b)))
        return cmp.Or(revA-revB, a-b)
    })
    return nums
}

func main() {
    nums := []int{3, 6, 5, 8}
    result := sortByReflection(nums)
    fmt.Println(result)
}

# -*-coding:utf-8-*-

def sort_by_reflection(nums):
    def reverse_bits(n):
        # 将整数转换为二进制字符串，反转并去掉末尾的0
        if n == 0:
            return0
        # 获取二进制表示（去掉'0b'前缀）
        binary = bin(n)[2:]
        # 反转字符串
        reversed_binary = binary[::-1]
        # 转换为整数
        returnint(reversed_binary, 2)
    
    def sort_key(num):
        rev = reverse_bits(num)
        # Python的排序是稳定的，我们通过返回元组来实现多级排序
        return (rev, num)
    
    # 使用sort()方法进行原地排序
    nums.sort(key=sort_key)
    return nums

def main():
    nums = [3, 6, 5, 8]
    result = sort_by_reflection(nums)
    print(result)

if __name__ == "__main__":
    main()

#include <iostream>
#include <vector>
#include <algorithm>
#include <bit>
#include <compare>

int reverseBits(int n) {
    if (n == 0) return0;

    unsigned int u = static_cast<unsigned int>(n);
    // C++23 提供 std::bit_reverse
    // 如果编译器支持，可以使用：#if __cpp_lib_bit_reverse
    // 否则使用手动实现

    // 手动实现32位反转
    u = ((u & 0x55555555) << 1) | ((u & 0xAAAAAAAA) >> 1);
    u = ((u & 0x33333333) << 2) | ((u & 0xCCCCCCCC) >> 2);
    u = ((u & 0x0F0F0F0F) << 4) | ((u & 0xF0F0F0F0) >> 4);
    u = ((u & 0x00FF00FF) << 8) | ((u & 0xFF00FF00) >> 8);
    u = (u << 16) | (u >> 16);

    return static_cast<int>(u);
}

int leadingZeros(int n) {
    if (n == 0) return32;
    return std::countl_zero(static_cast<unsigned int>(n));
}

std::vector<int> sortByReflection(std::vector<int>& nums) {
    std::ranges::sort(nums, [](int a, int b) {
        int revA = reverseBits(a) >> leadingZeros(a);
        int revB = reverseBits(b) >> leadingZeros(b);

        if (revA != revB) {
            return revA < revB;
        }
        return a < b;
    });

    return nums;
}

int main() {
    std::vector<int> nums = {3, 6, 5, 8};
    std::vector<int> result = sortByReflection(nums);

    for (size_t i = 0; i < result.size(); ++i) {
        std::cout << result[i] << (i < result.size() - 1 ? ", " : "");
    }
    std::cout << std::endl;

    return0;
}