Question

given is any sequence of integers like 23 7 13 4 8 6. I want to detect local minima and maxima with the following rules:

• the first number in the sequence is a local minimum when the following number is greater
• the last number in the sequence is a local minimum when the previous number is greater
• a number in the sequence is a local minimum when it is smaller than the previous and the following number

I can use the methods hasNextInt and getNextInt.

Currently I am thinking about the algorithm. But I am not sure whether I understand the logic. First I build a tuple and compare its numbers. E.g. I compare 23 and 7. 7 is the local minimum. What would I do then? Build a triple? But what numbers has that triple, 23 7 13 or 13 4 8? I am not sure.

Any ideas?

Update:

Let’s say we store the left neighbour and the number in the middle of three numbers:

left    middle    current

0        0         23

23       0         7

23       7         13 <- you have a triple, compare => minimum 7

What would happen then? Set the vars to 0 and start with the next number 4? Or store 7 in left, 13 in the middle to have 4 as current?

Update (this code seems to work):

    int left   = 0;
    int center = 0;
    while(hasNextInt()){
        int current = getNextInt();

        if((left != 0) && (center != 0)){
            if(current > center && center < left){
                System.out.println("Min: "+center);
                left = center; center = current;
            }else{
                left = center; center = current;
            }
        }else if((left != 0) && (center == 0)){
            if(left < current){
                System.out.println("Min: "+left);
                center = current;
            }else{
                center = current;
            }
        }else if((left == 0) && (center == 0)){
            left = current;
        }
    }

    if(left > center){
        System.out.println("Min: "+center);
    }

Thanks for your help!

Answer 1

What you have there looks like a good start.

However, only looking at tuples will no be enough, because you must look at three numbers to detect a local minimum – so you will have to extend your algorithm.

To understand how to do this, try to work a simple example on paper. How would you go about manually finding the local minima? Can you do something similar in your program?

Feel free to post an updated version of your program (by editing the question, adding the new code to the bottom), then we can help if you are still stuck.

Answer to your edit:

What would happen then? Set the vars
to 0 and start with the next number 4?
Or store 7 in left, 13 in the middle
to have 4 as current?

You cannot just set everything to 0; you still need the last two numbers of your triple to start the next triple, because your triples behave like a windows sliding over the list of numbers (this is often referred to as a “sliding window” technique, as many algorithms use it).

You can copy the numbers to their new variables manually.

For more elegance, you could implement this in a separate “Triplet” class. Ideas to consider: That class could check for minima, and let you add a new number, automatically “pushing out” the oldest number.