无需暴力枚举的传感器原始与校准数据全组合生成方法

实现思路 #

• 首先生成校准数组的所有无重复全排列，对应6种轴配对规则
• 生成所有符号组合，每个原始值、每个校准值均可取正负，共2^6=64种符号规则
• 遍历所有排列+符号的组合，生成符合要求的配对数组后调用processPair方法即可，无需手动枚举所有384种情况

完整Java实现代码 #

import java.util.ArrayList;
import java.util.List;

public class SensorCombinationGenerator {
    public static void main(String[] args) {
        float[] rawValues = {169.58185f, 20.343851f, 1.4982328f};
        float[] calValues = {110.131454f, 4.442127f, 7.5981708f};
        
        // 生成校准值的所有全排列
        List<float[]> calPermutations = new ArrayList<>();
        generatePermutations(calValues, 0, calPermutations);
        
        // 遍历所有配对排列
        for (float[] calPerm : calPermutations) {
            // 遍历所有64种符号组合，二进制位0-2对应原始值符号，3-5对应校准值符号
            for (int signFlag = 0; signFlag < 64; signFlag++) {
                float[] processedRaw = new float[3];
                float[] processedCal = new float[3];
                
                // 生成带符号的原始值数组
                for (int i = 0; i < 3; i++) {
                    int sign = ((signFlag >> i) & 1) == 1 ? -1 : 1;
                    processedRaw[i] = rawValues[i] * sign;
                }
                
                // 生成带符号的当前排列校准值数组
                for (int i = 0; i < 3; i++) {
                    int sign = ((signFlag >> (i + 3)) & 1) == 1 ? -1 : 1;
                    processedCal[i] = calPerm[i] * sign;
                }
                
                // 调用自定义处理方法
                processPair(processedRaw, processedCal);
            }
        }
    }

    // 回溯法生成数组全排列
    private static void generatePermutations(float[] arr, int depth, List<float[]> permutations) {
        if (depth == arr.length) {
            permutations.add(arr.clone());
            return;
        }
        for (int i = depth; i < arr.length; i++) {
            swap(arr, depth, i);
            generatePermutations(arr, depth + 1, permutations);
            swap(arr, depth, i); // 回溯复位
        }
    }

    private static void swap(float[] arr, int i, int j) {
        float temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    // 你的原有处理方法，此处仅做示例
    private static void processPair(float[] raw, float[] cal) {
        // 原有业务逻辑
    }
}

逻辑验证 #

• 最终生成的组合总数为 6 * 64 = 384，完全覆盖所有需求场景
• 如果后续确认某类数值不需要变号，仅需要修改符号判断逻辑和循环范围即可，扩展性较强

内容的提问来源于stack exchange，提问作者confused