Guessing method (pretty basic java)

Question

I'm using the following code to add a guessed consonant to a string of stars if the guessed consonant is part of the original word. Initially I was keeping wordWithGuess between calls to getCurrentResult. But the result of this was that the new content was added to the end, and wordWithGuess kept getting longer (instead of just replacing the most recently guessed letter).

When running the code below, the output is

After guessing r: *****r******
After guessing s: ************
After guessing t: **tt********
After guessing l: ********ll**
After guessing n: ***********n

My goal is for it to be:

After guessing r: *****r******
After guessing s: *****r******
After guessing t: **tt*r******
After guessing l: **tt*r**ll**
After guessing n: **tt*r**ll*n

Sample code follows:

public class Sample {
    String targetWord;
    String wordWithGuess = "";

    public Sample(String targetWord) {
        this.targetWord = targetWord;
    }

    public void guess(String consonant) {
        wordWithGuess = "";

        for (int i = 0; i < targetWord.length(); i++) {
            if (targetWord.substring(i, i + 1).equals(" ")) {
                wordWithGuess += " ";
            } else if (targetWord.substring(i, i + 1).equals(consonant)) {
                wordWithGuess += consonant;
            } else {
                wordWithGuess += "*";
            }
        }
    }

    public String getCurrentResult() {
        return wordWithGuess;
    }

    public static void main(String args[]) {
        String targetWord = "bitterbollen";

        Sample sample = new Sample(targetWord);

        String[] guesses = { "r", "s", "t", "l", "n" };

        for (String guess : guesses) {
            sample.guess(guess);
            System.out.println("After guessing " + guess + ": "
                    + sample.getCurrentResult());
        }
    }
}

Answer 1

The problem is that you need to keep some information between calls to guess(). This means either storing all values of consonant, or finding a way to merge the old value of wordWithGuess with the new consonant.

The first option means something like

import java.util.Set;
import java.util.HashSet;

class Sample {

    // ...

    Set<String> guesses = new HashSet<String>();

    public void guess(String consonant) {
        guesses.add(consonant);

        wordWithGuess = "";

        for (int i = 0; i < targetWord.length(); i++) {
            String cursor = targetWord.substring(i, i + 1);

            if (cursor.equals(" ")) {
                wordWithGuess += " ";
            } else if (guesses.contains(cursor)) {
                wordWithGuess += cursor;
            } else {
                wordWithGuess += "*";
            }
        }
    }

    // ...

}

This stores the old guesses as a Set. Instead of just checking for the last guess, guess() now includes any letter that has been guessed.

In fact you could even add a constructor to initialize the set with any characters that you want to include by default. This will let you eliminate the check for a space, as it'll be in the initial set of guesses:

import java.util.Set;
import java.util.HashSet;

class Sample {

    // ...

    Set<String> guesses;

    public Sample() {
        this.guesses = new HashSet<String>();
        guesses.add(" ");
    }

    public void guess(String consonant) {
        guesses.add(consonant);

        wordWithGuess = "";

        for (int i = 0; i < targetWord.length(); i++) {
            String cursor = targetWord.substring(i, i + 1);

            if (guesses.contains(cursor)) {
                wordWithGuess += cursor;
            } else {
                wordWithGuess += "*";
            }
        }
    }

    // ...

}

The other option would be to update wordWithGuess to include the new guess. In C it's easy to do this, because strings can be modified just like character arrays (for example, wordWithGuess[i] = consonant. Java guards its strings more closely, but there's no reason why one can't use an array of char to the same effect.

public class Sample {
    String targetWord;
    char[] currentResult;

    public Sample(String targetWord) {
        this.targetWord = targetWord;
        currentResult = new char[targetWord.length()];
        for (int i = 0; i < targetWord.length(); i++) {
            if(targetWord.charAt(i) == ' ') {
                currentResult[i] = ' ';
            } else {
                currentResult[i] = '*';
            }
        }
    }

    public void guess(String consonant) {
        for (int i = 0; i < targetWord.length(); i++) {
            String cursor = targetWord.substring(i, i + 1);

            if (cursor.equals(consonant)) {
                currentResult[i] = consonant.charAt(0);
            }
        }
    }

    public String getCurrentResult() {
        return new String(currentResult);
    }

    // ...

}

Answer 2

you should store all consonants guessed, and change word.substring(i, i + 1).equals (consonant)

to something like

word.substring(i, i + 1) exists in the consonant guessed. (it is pusedo-code of course)

Some more hints: have a look in Set (or more precisely, HashSet), or String's contains() or indexOf() method.

---

Some extra opinions to you:

you are calling word.substring(i, i + 1) without storing the returned string, that's a meaningless call.

Instead calling word.substring(i, i + 1) that many times, you can call it once and use the returned string for multiple comparison.

And, as you are comparing one char each time, you should use char to store the character, and using charAt() to get the character at certain position.

Answer 3

You'll want to store the result of the previous iteration. Have the code oldWordWithGuess = wordWithGuess at the end of the for loop.

Then, in your loop you'll want the following code:

...
if(oldWordWithGuess[i] != `*`) {
    wordWithGuess += oldWordWithGuess[i];
} else if (word.substring(i, i + 1).equals (" ")) {
...

That way it will put any previous guesses in.

Answer 4

I've actually found a different solution where I use a char Array and store every letter in a different element of that array. Am I actually allowed to do this? Does this not require too much resources for what it does?