차이를 기준으로 배열을 10의 배 수당 한 행으로 필터링 하시겠습니까?

다른 방식으로 생각해야한다고 생각합니다. 당신이 원하는 것은 각 행에 대해 10의 배수에서 거리를 찾는 것입니다.

• 10의 가장 가까운 배수는 다음 식으로 주어집니다. double mult = 10d * Math.round(v / 10d)
• 10의 배수로부터의 거리는 다음 식으로 주어집니다. double delta = Math.abs(v - mult)
• 의 모든 값에 mult대해 원하는 행은 가장 작은 delta값을 가진 행 입니다.

따라서 행을 한 번만 반복하면됩니다.

1. 받기 beam_value행과 그것의 발견 mult과 delta.
2. 행의이 경우 delta가까운 이전에 발견 된 것보다 delta위해 mult, 그 다음에 그 행을 기록 mult, 그렇지 않으면 무시한다.
3. 더 이상 행이 없을 때까지 반복하십시오.

또한이 접근 방식은 다른 접근 방식으로는 방지하기 어려운 10의 배수 이상에 대해 단일 행이 기록되는 것을 방지합니다.

예를 들어 (그리고 SQL 쿼리가 없기 때문에 데이터를 가짜로 만들었습니다). 입력 데이터 :

`0.5, 12.10, 13.00, 16.01, 21.52`

올바른 출력을 제공합니다 (인덱스 1은 10인덱스 2보다 더 가깝고 인덱스 4는 20인덱스 3보다 더 가깝습니다 ).

   10x 행 값
     0 0 0.5000
    10 1 12.1000
    20 4 21.5200

코드 :

public static void findClosestRowsToMultiplesOfTen() {
    // fake row values
    double[] vals = new double[]{ 0.5, 12.10, 13.00, 16.01, 21.52 };

    //  get the max value, and its multiple of ten to get the number of buckets
    double max = Double.MIN_VALUE;
    for (double v : vals) max = Math.max(max, v);
    int bucketCount = 1 + (int)(max/10);

    //  initialise the buckets array to store the closest values
    double[][] buckets = new double[bucketCount][3];
    for (int i = 0; i < bucketCount; i++){
        // store the current smallest delta in the first element
        buckets[i][0] = Double.MAX_VALUE; 
        // store the current "closest" index in the second element
        buckets[i][1] = -1d;
        // store the current "closest" value in the third element
        buckets[i][2] = Double.MAX_VALUE;
    }

    //  iterate the rows
    for (int i = 0; i < vals.length; i++)
    {
        //  get the value from the row
        double v = vals[i];
        //  get the closest multiple of ten to v
        double mult = getMultipleOfTen(v);
        //  get the absolute distance of v from the multiple of ten
        double delta = Math.abs(mult - v);
        //  get the bucket index based on the value of `mult`
        int bIdx = (int)(mult / 10d);
        //    test the last known "smallest delta" for this bucket
        if (buckets[bIdx][0] > delta)
        {
            //  this is closer than the last known "smallest delta"
            buckets[bIdx][0] = delta;
            buckets[bIdx][1] = i;
            buckets[bIdx][2] = v;
        }
    }

    //   print out the result
    System.out.format("    10x row value%n");
    for (int i = 0; i < buckets.length; i++)
    {
        double[] bucket = buckets[i];
        int multipleOfTen = i * 10;
        double rowIndex = bucket[1];
        double rowValue = bucket[2];
        System.out.format("    %,2d %,4.0f %.4f%n", 
          multipleOfTen, rowIndex, rowValue);
    }
}
public static double getMultipleOfTen(double v)
{
    return 10d * Math.round(v / 10d);
}