Thread: how to ensure that my method wont return the same random number twice in a row

I want to use this idea in a different context but for the sake of the argument lets suppose I have this method:

 
public int random number(int range)
{
    Random rand = new Random();
    int randomNumber = rand.nextInt(range);
                            .
                            .
                            .
    return randomNumber;
}

Any suggestions how to avoid getting the same random number twice in a row?

The simple way would be to remember what value you returned the last time.
When your method is called again and the random value you got is the same as last time you simply produce another random number.

In theory this could (in the worst case) end with an infinite loop and your problem will crash.
In practice this is pretty much impossible.

Well, not in theory... trying to solve this problem with a similar idea, I declared a field inside the class to hold the result of the previous returned number and use that in a condition statement so that to generate a new random number if they match, but I came to a dead end because of the possibility to get again the same random number and so on and so on.... When I tried to use a loop it crushed ... Actually I am trying this all day and no result...
But this is part of an exercise in the book I am studding so It should be a way...

There's more than one way, but one is to use a Set to hold the random numbers generated. Attempting to add. add()ing each new random number as it is created will return either false, indicating that the number already exists in the Set, or true, a new random number has been created. Checking the size of the set should also indicate when all possible random numbers in a range have been created.

My concern was not to return the same random number twice in the row and not to ensure that the same random number wont be returned at all...
Do you have any suggestion to that?
To put you in the context of my exercise I will explain exactly what I want:
The project is a technical support system that generates a response according to users question for a software they have purchased.
When the user's input doesn't contain any word that is being used as key to a hashMap in order to generate the related response that is being held as a value to that key, it generates a random response from several ones that are stored in an Arrayylist. The exercise is to ensure that the same random response is never repeated twice in a row.
Below are the related methods method:

 
    public String generateResponse(HashSet<String> words)
    {
        for(String word : words) {
            String response = responseMap.get(word);
            if(response != null) {
                return response;
            }
        }
        return pickDefaultResponse();
    }
 
 public String pickDefaultResponse()
    {
        int r = randomGenerator.nextInt(defaultResponses.size());
        return defaultResponses.get(r);
 
    }

the pickDefaultResponse is that I have to modify so that it wont generate the same result twice in a row. Any suggestions how to do that?

You mean is impossible? I cant understand why a book has an exercise that it has no possible solution.... It mentions though that it is a quite challenging programming exercise...

Here is some pseudo code for my solution from post #2:

1) generate random number i
2) check against previous random number
3) if equal, go to 1)
4) save i as "new" previous number
5) return i




A different approach would be:

1) generate random number i
2) check against previous random number
3) if equal increment i by 1
4) save i as "new" previous number
5) return i

This way you would definitely always return, even in the worst case. I would still argue, that the result is random.

Originally Posted by Cornix

A different approach would be:

1) generate random number i
2) check against previous random number
3) if equal increment i by 1
4) save i as "new" previous number
5) return i

This way you would definitely always return, even in the worst case. I would still argue, that the result is random.

This was my initial idea, also, but it fails because the returned value might now be out of range. A fix would only get messy, because there could be a very narrow range and whatnot.