-1

如果猜测的辅音是原始单词的一部分，我正在使用以下代码将猜测的辅音添加到一串星中。最初，我一直wordWithGuess在调用getCurrentResult. 但这样做的结果是，新内容被添加到了末尾，并且wordWithGuess不断变长（而不是仅仅替换最近猜测的字母）。

运行下面的代码时，输​​出是

猜到r后：*****r******
猜后s：************
猜到t后：**tt********
猜后 l: ********ll**
猜测n后：***********n

我的目标是：

猜到r后：*****r******
猜到s后：*****r******
猜到t后：**tt*r******
猜到l后：**tt*r**ll**
猜测n后：**tt*r**ll*n

示例代码如下：

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());
        }
    }
}
4

4 回答 4

1

问题是您需要在调用guess(). 这意味着要么存储 的所有值consonant，要么找到将旧值wordWithGuess与新辅音合并的方法。

第一个选项意味着类似

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 += "*";
            }
        }
    }

    // ...

}

这会将旧的猜测存储为Set. 现在不仅检查最后的猜测，guess()还包括已猜测的任何字母。

事实上，您甚至可以添加一个构造函数来使用您希望默认包含的任何字符来初始化该集合。这将使您消除对空格的检查，因为它将在最初的猜测集中：

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 += "*";
            }
        }
    }

    // ...

}

另一种选择是更新 wordWithGuess 以包含新的猜测。在 C 中很容易做到这一点，因为字符串可以像字符数组一样被修改（例如，wordWithGuess[i] = consonant.Java 更密切地保护它的字符串，但是没有理由不能使用数组char来达到相同的效果。

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);
    }

    // ...

}
于 2013-01-07T01:30:24.600 回答
1

你应该存储所有猜测的辅音，并改变 word.substring(i, i + 1).equals (consonant)

类似于

word.substring(i, i + 1) exists in the consonant guessed. （当然是pusdo代码）

更多提示：查看 Set（或更准确地说，HashSet），或 String 的 contains() 或 indexOf() 方法。

给你一些额外的意见：

您正在调用 word.substring(i, i + 1) 而不存储返回的字符串，这是一个毫无意义的调用。

而不是多次调用 word.substring(i, i + 1) ，您可以调用一次并使用返回的字符串进行多重比较。

而且，当您每次比较一个字符时，您应该使用 char 来存储字符，并使用 charAt() 来获取某个位置的字符。

于 2013-01-07T02:30:39.097 回答
0

您需要存储上一次迭代的结果。将代码oldWordWithGuess = wordWithGuess放在 for 循环的末尾。

然后，在您的循环中，您将需要以下代码：

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

这样它就会把之前的猜测放进去。

于 2013-01-07T01:41:32.077 回答
0

我实际上找到了一个不同的解决方案，我使用 char 数组并将每个字母存储在该数组的不同元素中。我真的可以这样做吗？这是否不需要太多资源来完成它的工作？

于 2013-01-07T14:20:14.473 回答