Quelle est la meilleure méthode pour obtenir l'index d'un tableau de chaînes ou de caractères?

Question

Je voudrais savoir quel est le meilleur moyen d'obtenir l'index d'une lettre spécifique dans un mot. La raison pour laquelle je fais ceci est parce que je fais et modifie un jeu de pendu. Je suis déjà fini avec le jeu et ça marche bien, mais je veux mettre en place un système basé sur les scores. J'ai créé une méthode appelée keepScore() qui prend une valeur booléenne pour voir si la réponse est bonne ou fausse. Si c'est juste, je vais ajouter 10 points pour chaque lettre trouvée. Si c'est faux, je vais déduire 10 points. Ma méthode keepScore() est mal implémentée toute aide?

Hangman.java

import Game.Game; 
import Prompter.Prompter; 

/* This class is the main class that starts the game. 
* It instantiates the Game and Prompter objects. 
*/ 
public class Hangman { 

    public static void main(String[] args) { 
     //Check if an argument has been passed, we expect the answer to be passed 
     if(args.length == 0) { 
      System.out.println("Expected: Java Hangman <answer>"); 
      System.err.println("Answer is required!"); 
      System.exit(1); 
     } 

     System.out.println("Welcome to Hangman!"); 

     //Create an instance of our game 
     Game game = new Game(args[0]); 
     //Create an instance of our prompter 
     Prompter prompter = new Prompter(game); 

     //Starts the game 
     while (game.getRemainingTries() > 0 && !game.isWon()) { 
      prompter.displayProgress(); 
      prompter.promptForGuess(); 
     } 
     //Displays the outcome of the game 
     prompter.displayOutcome(); 
    } 
} 

Game.java

package Game; 

/* This class is responsible for implementing the game 
* logic. 
*/ 
public class Game { 
    //Declare our member variables 
    public final static int TOTAL_TRIES = 3; 
    public final static int MAX_SCORE_POINTS = 10; 
    private String mAnswer; 
    private String lettersHit; 
    private String lettersMissed; 
    private int score; 

    //Default constructor 
    public Game(String answer) { 
     //Initialize our member variables 
     mAnswer = answer.toLowerCase(); 
     lettersHit = ""; 
     lettersMissed = ""; 
    } 

    //This method checks to see if the letter was a hit or a miss 
    public boolean checkLetter(char letter){ 
     letter = validateGuess(letter); 
     boolean isHit = mAnswer.indexOf(letter) != -1; 
     //If correct 
     if (isHit) { 
      //Add the letter to the lettersHit pool 
      lettersHit += letter; 
      keepScore(isHit); 
      System.out.println("Hit! Score: " + score); 

     }else { 
      //Add the letter to the lettersMissed pool 
      lettersMissed += letter; 
      keepScore(isHit); 
      System.out.println("Missed! Score: " + score); 
     } 
     return isHit; 
    } 

    private void keepScore(boolean isHit) { 
     if(isHit) { 
      for (int i = 0; i < lettersHit.length(); i++) { 
       score += MAX_SCORE_POINTS; 
      } 
     } else { 
      for (int i = 0; i < lettersMissed.length(); i++) { 
       score -= MAX_SCORE_POINTS; 
      } 
     } 
    } 

    /* 
    This method handles an empty string input. For example, 
    if the user were to press enter on input a 0 length String 
    will cause the program to crash. 
    */ 
    public boolean checkLetter(String letters) { 
     if (letters.length() == 0) { 
      throw new IllegalArgumentException("No letter entered"); 
     } 
     return checkLetter(letters.charAt(0)); 
    } 

    //This method validates the user guess 
    private char validateGuess(char letter) { 
     //If the character is not a letter 
     if (!Character.isLetter(letter)) { 
      //Ask user for a valid letter 
      throw new IllegalArgumentException("A letter is required!"); 
     } 
     //If entry was valid, convert character to lowercase 
     letter = Character.toLowerCase(letter); 

     //Check if the letter has been guessed already 
     if (lettersHit.indexOf(letter) != -1 || lettersMissed.indexOf(letter) != -1) { 
      throw new IllegalArgumentException("The letter " + letter + " has already been guessed"); 
     } 
     return letter; 
    } 

    //This method keeps track of the user's game progress 
    public String getCurrentProgress() { 
     String progress = ""; 
     //For each character in the array of strings of mAnswer 
     for (char letter : mAnswer.toCharArray()) { 
      char display = '-'; 
      if (lettersHit.indexOf(letter) != -1){ 
       display = letter; 
      } 
      progress += display; 
     } 
     return progress; 
    } 

    //Get the current remaining tries 
    public int getRemainingTries() { 
     return TOTAL_TRIES - lettersMissed.length(); 
    } 

    //Get the current answer 
    public String getAnswer() { 
     return mAnswer; 
    } 

    //This method checks if the game is won. 
    public boolean isWon() { 
     return getCurrentProgress().indexOf('-') == -1; 
    } 


    public int getScore(){ 
     return score; 
    } 
} 

Prompter.java

package Prompter; 
import Game.Game; 
import java.util.Scanner; 

/* This class is responsible for displaying instructions and information to the user 
* regarding the game. 
*/ 
public class Prompter { 
    //The game object 
    private Game mGame; 
    private boolean isHit; 
    private boolean acceptable; 

    //Default constructor 
    public Prompter(Game game) { 
     //Get the instance of our game 
     mGame = game; 
     isHit = false; 
     acceptable = false; 
    } 

    //This method prompts the user for a guess 
    public boolean promptForGuess() { 
     //Create an instance of scanner 
     Scanner scanner = new Scanner(System.in); 

     //Loop for input 
     do { 
      System.out.println("Please enter a letter: "); 
      String guess = scanner.nextLine(); 

      try { 
       isHit = mGame.checkLetter(guess); 
       acceptable = true; 
      }catch (IllegalArgumentException iae) { 
       System.out.printf("%s. Please try again!%n", iae.getMessage()); 
      } 
     } while (!acceptable); 
     return isHit; 
    } 

    //This method displays the progress 
    public void displayProgress() { 
     System.out.printf("You have %d tries to guess the answer" + 
       " before you are taken to the gallows. Try to solve: %s%n", mGame.getRemainingTries(), 
       mGame.getCurrentProgress()); 
    } 

    //This method displays the outcome of the game 
    public void displayOutcome() { 
     if(mGame.isWon()) { 
      System.out.printf("Congratulations! you won with %d tries remaining.%n" + 
        "Your total score: %d%n", mGame.getRemainingTries(), mGame.getScore()); 
     }else { 
      System.out.printf("Bummer! The answer was: %s", mGame.getAnswer()); 
     } 
    } 
} 

Answer 1

Regardez cette méthode de la vôtre:

private void keepScore(boolean isHit) { 
    if(isHit) { 
     for (int i = 0; i < lettersHit.length(); i++) { 
      score += MAX_SCORE_POINTS; 
     } 
    } else { 
     for (int i = 0; i < lettersMissed.length(); i++) { 
      score -= MAX_SCORE_POINTS; 
     } 
    } 
} 

Il n'ajoute pas MAX_SCORE_POINTS fois le nombre de bonnes lettres vous venez de trouver, il le fait avec le nombre de bonnes lettres dans lettersHit. Maintenant, qu'y a-t-il dans lettersHit? Eh bien, il y a toutes les lettres que vous avez trouvées depuis le début.

vous aurez donc avoir:

word to guess: anaconda 

letter: a 
lettersHit = "a", score += (lettersHit.length * 10) = 10 
letter: c 
lettersHit = "ac", score += (lettersHit.length * 10) = 30 

Vous pouvez simplement utiliser StringUtils.countMatches(mAnswer, letter); pour obtenir le nombre d'occurence, d'où le score.