Java无限流中的通用元素

Question

I have three infinite Java IntStream objects. I want to find the smallest element that is present in all three of them.

    IntStream a = IntStream.iterate(286, i->i+1).map(i -> (Integer)i*(i+1)/2);
    IntStream b = IntStream.iterate(166, i->i+1).map(i -> (Integer)i*(3*i-1)/2);
    IntStream c = IntStream.iterate(144, i->i+1).map(i -> i*(2*i-1));

I can always employ a brute force solution (without streams) which involves iterating in nested loops, but I was wondering if we can do it more efficiently with streams?

Answer 1

You need to iterate all 3 in parallel, advancing the one with the lowest value, checking if all 3 are equal.

You code will not find an answer for next value after 40755 , because the next value is 1_533_776_805 , which has intermediate value (before division by 2) higher than Integer.MAX_VALUE ( 2_147_483_647 ).

So, here is one way to use your streams, after changing them to long and guarding against overflow.

LongStream a = LongStream.iterate(286, i->i+1).map(i -> Math.multiplyExact(i, i+1)/2);
LongStream b = LongStream.iterate(166, i->i+1).map(i -> Math.multiplyExact(i, 3*i-1)/2);
LongStream c = LongStream.iterate(144, i->i+1).map(i -> Math.multiplyExact(i, 2*i-1));

OfLong aIter = a.iterator();
OfLong bIter = b.iterator();
OfLong cIter = c.iterator();

long aVal = aIter.nextLong();
long bVal = bIter.nextLong();
long cVal = cIter.nextLong();
while (aVal != bVal || bVal != cVal) {
    long min = Math.min(Math.min(aVal, bVal), cVal);
    if (aVal == min)
        aVal = aIter.nextLong();
    if (bVal == min)
        bVal = bIter.nextLong();
    if (cVal == min)
        cVal = cIter.nextLong();
}
System.out.println(aVal);

Answer 2

These functions are always increasing. So the code should stop when the magic equal triplet is found.

The thing to code is:

a) when a stream's current value is below any other, it can iterate next for itself.

b) when it meets the same candidate value, it waits for the 3rd stream to take a decision.

c) when it has a higher value than the all others, it changes the candidate and waits for both others.

Reference juggling.

There may not be a solution too (at least in short time).

Notice that stream c can only produce even numbers (when seeded with even). There might be some optimization there to skip a and b faster.

Answer 3

I don't think there is anything smart possible with stream API. The main reason is that you can't really go over one stream until some condition is met - instead, you look at current 3 elements and pick the next element from one of the streams before comparing the elements again.

The most efficient (and might be also the cleanest) solution is to use iterators and keep calling next() method on the right streams until the answer is found.

To start with, you can focus on two streams only and find their first common value:

while (elementA != elementB) {
    if (elementA < elementB) {
        elementA = iteratorA.next();
    } else {
        elementB = iteratorB.next();
    }
}

Then you need to do make third stream catch up with these two:

while (elementC < elementA) {
    elementC = iteratorC.next();
}

At this point there are two options:

• either elementC == elementA in which case you have the answer
• or elementC > elementA in which case you can go to next value on all three streams and start over

One thing to remember is the max value of integer. Because you have i^2 , this means that it will overflow for i about 46k, so you need to change streams of ints to streams of longs (the answer is about 1.5 billion - and that's after division by 2 in these functions).

Since you are doing exercises for practice, I don't think it's right to give you the full working code, but let me know if you still struggle with it ;)