Number of occurrence IntStream Java

Question

I want to define a method named countRepeats that takes in a List of digits 0 to 9 and returns the number of occurrences of adjacent repeated letters.

For example,

Test case 1: the array {0, 1, 2, 2, 1, 2, 2, 1, 3, 3, 1} has three occurrences of repeated digits

Test case 2: the array {0, 1, 1, 1, 1, 2} has one occurrence

Below are my codes:

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();
}

However, I failed to get the desired outcome for my test case 2. Anyone can enlighten me ?

Try writing it using a simple for loop. Then use that to help you convert it to a stream. — DragonAssassin, Oct 10 '18 at 14:58
@DragonAssassin Or leave it as a simple for loop for maximum readability, though minimum cred. — Tom Hawtin - tackline, Oct 10 '18 at 21:46

Tom Hawtin - tackline · Accepted Answer · 2018-10-10T16:36:44.933

Building on the original poster's solution, if we check whether a repeated pair is part of a larger sequence (and check end of array) then we can avoid boxing.

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();
    }
}

This isn't really streams' strong point.

(The line

                   i+2 >= array.length ||

really should be

                   i >= array.length-2 ||

to avoid an integer overflow causing an ArrayOutOfBoundsException. Old languages and their broken integers...)

But would you mind explaining to me the filter part? I wouldn't sure how it works? — , Oct 11 '18 at 00:00
@goodstudent404 The first part is the same as you had. The second part is just discarding if it isn't the last pair in the run. Length checking done before lazy-or so we don't get an exception. — Tom Hawtin - tackline, Oct 11 '18 at 02:06

ernest_k · Answer 2 · 2018-10-10T16:12:03.920

1

This uses predicates that compare consecutive elements:

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();
}

The first filter operation is intended to eliminate duplicates to force a count of 1 where an element is repeated more than 2 times in a row. The second one simply removes elements that aren't repeated consecutively.

edited Oct 10 '18 at 16:12

answered Oct 10 '18 at 15:19

ernest_k

44,416
5
53
99

This helped :) Thank you so much for the answer! – Oct 10 '18 at 23:50

Number of occurrence IntStream Java

2 Answers2