Random number guessing game with limitations after each guess

Question

I am making a number guessing game:

• The computer generates a number inside an interval
• I try to guess it and receive a reply whether it's higher/lower than my guess or equals to my guess and I've won
• There is an interval in which I can guess, as well as a guess attempt limit

The trick is, however, that I need to implement another condition: each guess should "shrink" the interval in which I'm able to guess. For example: computer generates 50, I guess 25, computer replies "The random number is larger.". Now knowing that, I should not guess anything lower than 25 again, it's unreasonable. In case I guess i.e. 15, the computer should reply "The guess doesn't make sense.". I understand that I somehow need to save each guess value to a new variable, but nothing seems to work. I'm a beginner, please bear with the following code, I've tried a lot of things:

public String guess(int guess)
{
    
    int lowerBound = 0;
    int upperBound = 99;
    
    Set<Integer> lowerGuesses = new TreeSet<>();
    Set<Integer> higherGuesses = new TreeSet<>();

    if (gameOver) {
        return "The game is over.";
    }
    
    if (guess < 0 || guess > 99) {
        return "The guess is out of bounds.";
    }
        
    if (guessCount < maxGuessCount) {
            
        if (guess < secretNumber) {       
            if (lowerGuesses.contains(guess)) {
                return "The guess doesn't make sense.";
            }
            else {
            guessCount++;
            lowerBound = guess;
            lowerGuesses.add(guess);
            
            return "The random number is larger."; 
            }
        }

        if (guess > secretNumber) {
            if (higherGuesses.contains(guess)) {
                return "The guess doesn't make sense.";
            }
            else {
            guessCount++;
            upperBound = guess;
            higherGuesses.add(guess);
            
            return "The random number is smaller.";
            }
        }
        
        if (lowerGuesses.contains(guess)) {
                return "The guess doesn't make sense.";
        }
        
        if (higherGuesses.contains(guess)) {
                return "The guess doesn't make sense.";
        }
        
    }
    
    if (guess < lowerBound || guess > upperBound) {
        return "The guess doesn't make sense.";
    }
    
    if (guessCount == maxGuessCount) {
        gameOver = true;
        victorious = false;
        return "Ran out of guess attempts.";
    }
    
    guessCount++;
    gameOver = true;
    victorious = true; 
    return "You won.";
    }

Thank you in advance!

Answer 1

First, to avoid confusion, let's rename the method in order to make sure that its name is not an exact match with its parameter, so this is how it should look like:

public String makeGuess(int guess)

avoid naming different entities in the same name space with the exact same name (local variables being present in different methods or parameters having similar names with data members for the purpose of initialization are an exception). From now on, you will call the method as makeGuess(25), for example.

Now, to the actual problem. You have an incorrect assumption. You assume that you need to keep track of past intervals. That's not the case. You can just change the edges of the intervals. Also, your code is superfluous, I advise you to refactor it. Finally, you always initialize upper bounds, local bounds and higher and lower guesses as local variables, so they will never be kept track of. Instead of this, you need to perform the following simple measures in order to make this work:

Define the bounds and limit as data members

protected int lowerBound = 0;
protected int higherBound = 99;
protected int lb = 0;
protected int hb = 99;
protected int limit = 5;
protected int guessCount = 0;
protected int randomizedNumber; //Initialize this somewhere

Note that I have hard-coded some values. You might want to make this dynamic with initialization and stuff like that, but that's outside the scope of the answer. lowerBound, higherBound, limit are game settings. while lb, hb, guessCount represent the game state. You could separate this logic into another class, but for the sake of simplicity, even though I would program differently, I will leave them here in this case.

Have a method that initializes the game

public void initialize() {
    lb = lowerBound;
    hb = higherBound;
    guessCount = 0;
}

So you separate your concern of game initialization from the outer logic of starting and maintaining a game.

Implement makeGuess in a simplistic way

public String makeGuess(int guess) {
    if (++guessCount >= limit) return "The game is over.";
    else if ((lb > guess) || (hb < guess)) return "The guess doesn't make sense";
    else if (randomizedNumber == guess) return "You won.";
    else if (guess < randomizedNumber) {
        hb = guess;
        return "The random number is smaller.";
    } else {
        lb = guess;
        return "The random number is larger.";
    }
}

NOTE: I dislike mixing up the logic with the output layer, the reason I did it in the method above was that you have mentioned you are a beginner and my intention is to make this answer understandable for the person who just begun programming and is very confused. For the purpose of actual solutions, you should return a state and in a different layer process that state and perform the console/UI operations you need. I will not go through the details now, as it would also be outside of scope, but for now, please have some success with the solution above, but THEN you should DEFINITELY look into how you need to code, because that is almost as important as making your code work.