Question

我想定义一个名为countRepeats的方法，该方法接受0到9的数字列表，并返回相邻重复字母的出现次数。

例如，

测试用例1：：数组{0、1、2、2、1、2、2、1、3、3、1}出现了三个重复的数字

测试用例2：数组{0，1，1，1，1，2}发生了一次

下面是我的代码：

List<Integer> intlist = new ArrayList<Integer>();
        int [] array = new int[]{};
        while(sc.hasNext()){
          intlist.add(sc.nextInt());
          array = intlist.stream().mapToInt(i->i).toArray();  
        }
        System.out.println("Number of occurrences: " + countRepeats(array));

public static long countRepeats(int [] array){
      return IntStream.range(0, array.length-1)
                    .filter(n -> array[n] > 0)
                    .filter(i -> (array[i] == array[i+1]))
                    .peek(System.out::println)
                    .count();
}

但是，我的测试用例2未能获得理想的结果。有人可以启发我吗？

Answer 1

基于原始发布者的解决方案，如果我们检查重复的对是否属于较大序列的一部分（并检查数组的末尾），则可以避免装箱。

var testVal = 11.11;
var childGrid = $('#SomePayments_' + paymentId).data('kendoGrid');
var childRow = $(e).closest('tr');
var childData = childGrid.dataItem(childRow);

childData.OrderLevel = "A";
//childGrid.refresh();

// Get reference to parent row and payment data.
var detailRow = childRow.closest('div');
var parentRow = detailRow.closest('tr').prev()[0];
var paymentData = $("#PaymentsGrid").data("kendoGrid").dataItem(parentRow);


paymentData.ShortageAmt = testVal;
paymentData.UpstartAmt = testVal;

这并不是真正的优势。

（行

import java.util.*;
import java.util.stream.*;

interface CountRepeats {
    static void main(String[] args) {
        test(0, 1, 2, 2, 1, 2, 2, 1, 3, 3, 1);
        test(0, 1, 1, 1, 1, 2);
    }
    static void test(int... digits) {
        System.err.println(
            countRepeats(digits)+": "+Arrays.toString(digits)
        );
    }
    static long countRepeats(int[] array) { 
        return IntStream.range(0, array.length-1)
            .filter(i ->
                array[i] == array[i+1] && (
                   i+2 >= array.length ||
                   array[i] != array[i+2]
                )
             )
             .count();
    }
}

应该是

                   i+2 >= array.length ||

避免整数溢出引起i >= array.length-2 ||。旧语言及其残破的整数...）

Answer 2

这使用比较连续元素的谓词：

public static long countRepeats(int [] array){

      return IntStream.range(1, array.length)
            .filter(i -> i - 2 < 0 || array[i - 2] != array[i])
            .filter(i -> array[i] == array[i - 1])
            .count();
}

第一个filter操作旨在消除重复，以强制计数为1，其中元素连续重复两次以上。第二个只是删除不连续重复的元素。

发生次数IntStream Java

2 个答案: