Question

我有一个带有浮点值的未排序列表。我可以从中创建图形。但是现在，我想基于该图中的起伏创建批处理。

例如，我有一个如下列表 [6.17，6.13，6.12，6.19，6.2，6.21，6.28，6.17，6.2，6.28]

第一批将从6.17减少到6.12（索引0到索引2）。

然后第二批将从6.12增加到6.28（索引3到索引6）

我能想到的就是创建两个方法增加（列出值）-获取所有增量值递减（列出值）-获取所有递减值

每当我发现上次访问的元素的子列表中的值突然下降时，就在递增（）方法中调用reduce（）方法

但是我不认为这是个好主意。

Please find the graph image for reference

我有一个对象TimeAnalysis，其中包含开始和结束值。在第一种情况下，开始= 6.17，结束= 6.12。在第二种情况下，start = 6.12和end = 6.28

我想获取TimeAnalysis对象的列表。

Answer 1

您可以创建一个存储值列表和Batch类型的类。

class Batch {
  enum BatchType {
    INCREASING,
    DECREASING
  };
  BatchType batchType;
  List<Float> values;
}

现在，您可以使用一种名为splitIntoBatches的方法，该方法返回Batch列表。

public List<Batch> splitIntoBatches(List<Float> values) {
  // Traverse through the list once and create list of batches.
}

Answer 2

要实际拆分它们，可以使用Math.signum。

private List<List<Double>> splitAtInflectionPoints(List<Double> data) {
    List<List<Double>> split = new LinkedList<>();
    int start = 0;
    for (int i = 1; i < data.size() - 1; i++) {
        double leftSlope = Math.signum(data.get(i) - data.get(i - 1));
        double rightSlope = Math.signum(data.get(i + 1) - data.get(i));
        if (leftSlope != rightSlope) {
            split.add(data.subList(start, i + 1));
            start = i;
        }
    }
    if (start < data.size()) {
        split.add(data.subList(start, data.size()));
    }
    return split;
}

private void test() {
    List<Double> data = Arrays.asList(6.17, 6.13, 6.12, 6.19, 6.2, 6.21, 6.28, 6.17, 6.2, 6.28);
    for (List<Double> run : splitAtInflectionPoints(data)) {
        System.out.println(run);
    }
}

打印：

[6.17，6.13，6.12]

[6.12，6.19，6.2，6.21，6.28]

[6.28，6.17]

[6.17，6.2，6.28]

Answer 3

您可以遍历数组中的元素并跟踪其是增加还是减少或可能相同。

我使用了您提到的 TimeAnalysis 类，并编写了一个静态方法splitList()。

这是将时间浮动列表拆分为TimeAnalysis的列表。

public static List<TimeAnalysis> splitList(List<Float> timeList) {
    if(timeList.size() == 0) return new ArrayList<>();
    else if(timeList.size() == 1) {
        List<TimeAnalysis> batches = new ArrayList<>();
        batches.add(new TimeAnalysis(timeList.get(0), timeList.get(0)));
        return batches;
    }
    ArrayList<TimeAnalysis> batches = new ArrayList<>();
    // 0: same, 1: inc, 2: dec
    int type = -1;
    TimeAnalysis lastBatch = new TimeAnalysis(timeList.get(0), timeList.get
    batches.add(lastBatch);
    timeList.remove(0);
    for(float t : timeList) {
        switch(type) {
            case 0: // same
                if(t > lastBatch.end) { // inc
                    lastBatch = new TimeAnalysis(lastBatch.end, t);
                    batches.add(lastBatch);
                    type = 1;
                } else if(t < lastBatch.end) { // dec
                    lastBatch = new TimeAnalysis(lastBatch.end, t);
                    batches.add(lastBatch);
                    type = 2;
                }
                break;
            case 1: // inc
                if(t > lastBatch.end) { // inc
                    lastBatch.end = t;
                } else if(t < lastBatch.end) { // dec
                    lastBatch = new TimeAnalysis(lastBatch.end, t);
                    batches.add(lastBatch);
                    type = 2;
                } else { // same
                    lastBatch = new TimeAnalysis(lastBatch.end, t);
                    batches.add(lastBatch);
                    type = 0;
                }
                break;
            case 2: // dec
                if(t > lastBatch.end) { // inc
                    lastBatch = new TimeAnalysis(lastBatch.end, t);
                    batches.add(lastBatch);
                    type = 1;
                } else if(t < lastBatch.end) {
                    lastBatch.end = t;
                } else {
                    lastBatch = new TimeAnalysis(lastBatch.end, t);
                    batches.add(lastBatch);
                    type = 0;
                }
                break;
            default:
                if(t > lastBatch.end) type = 1;
                else if(t < lastBatch.end) type = 2;
                else type = 0;
                lastBatch.end = t;
                break;
        }
    }
    return batches;
}

当我跑步时：

Scanner in = new Scanner(System.in);
ArrayList<Float> input = new ArrayList<>();
for(int i=0; i<10; i++) input.add(in.nextFloat());
List<TimeAnalysis> output = TimeAnalysis.splitList(input);
for(TimeAnalysis batch : output) System.out.println("start: " + batch.start + ", end: " + batch.end);

并提供您的数据作为输入，我得到：

start: 6.17, end: 6.12
start: 6.12, end: 6.28
start: 6.28, end: 6.17
start: 6.17, end: 6.28

根据其中的递增和递减值拆分未排序的列表

3 个答案: