public class Hangman {
public static void ttt(String inputWord) { //setting up the game and declaring the secret word to be the input
int wordLength = inputWord.length(); //making new integer variable for length of word
String blanks = ""; //creating blanks string
for(int i = 0; i < wordLength; i++) { //making one blank for every letter of the word
blanks = blanks.concat("_ ");
}
System.out.println(blanks); //initially just to show user how many blanks/letters there are to guess
int points = 0; //setting up points int, one is awarded for each correct letter
int counter = 0; //setting up counter int, used to keep track of lives, reference lines 58+
ArrayList<String> usedChars = new ArrayList<String>(); //creating new array to store used letters
ArrayList<String> allChars = new ArrayList<String>(); //creating new array to store all letters
for(int i = 0; i < wordLength; i++) { //filling allChars with all the letters
allChars.add(inputWord.substring(i, i + 1));
}
while(points < wordLength) { //the entire game is run off of the points system, user needs as many points as number of letters to exit the while loop
Scanner reader = new Scanner(System.in); //making scanner thing
System.out.println("Guess: "); //asking user to guess a letter
String guess = reader.nextLine(); //string guess is set to the input
int checker = 0; //setting up checker int, used to check for duplicate answers
for(int k = 0; k < usedChars.size(); k++) { //for loop iterates through every item in usedChars and checks them against the user guess
if(!usedChars.get(k).equals(guess)) { //if the guess is different from that used letter
checker = checker + 1; //add one to the checker
}
else {} //or else nothing happens, this probably isn't necessary
}
if(checker == usedChars.size()) { //if statement protects the for loop inside, only runs if the checker got a point for every used letter (proving the guess was unique)
for(int i = 0; i < wordLength; i++) { //for loop iterates through every letter of the secret word, checking each against the guess
if(guess.equals(inputWord.substring(i, i + 1))) {
points = points + 1; //one point is added for every matching letter, refer back to line 20
System.out.println("Correct!"); //prints correct for every matching letter
}
else {} //again this probably isn't necessary
}
usedChars.add(guess); //after the guess is checked against the secret word, the guess is added to the used letters array
ArrayList<String> tempList = new ArrayList<String>(); //a temporary list is created to store the letters that haven't yet been guessed
for(int i = 0; i < allChars.size(); i++) { //for loop iterates through every string in the all letters array
for(int k = 0; k < usedChars.size(); k++) { //nested for loop iterates through every string in the used letters array
if(!allChars.get(i).equals(usedChars.get(k))) { //every string in allChars is checked against every string in usedChars
tempList.add(allChars.get(i)); //the temporary list is filled with the letters in allChars that were not found in usedChars
}
}
}
String inputWord2 = inputWord; //inputWord is duplicated, the copy will be manipulated but the original is still used in the above code
for(int i = 0; i < tempList.size(); i++) { //for loop iterates through every string in tempList (the list with the letters the user hasn't guessed yet)
inputWord2 = inputWord2.replace(tempList.get(i), "_"); //the full word has every letter it shares with tempList replaced with _ for the user to guess
}
System.out.println(inputWord2); //the word censored for any letters not guessed yet is printed
System.out.println("Used letters: " + usedChars); //the user is reminded which letters have already been used
}
else {
System.out.print("Sorry, that letter has already been used\n"); //if the checker didn't end up being equal to the number of items in usedChars then the guess was a repeat (found in usedChars)
}
counter = counter + 1; //tracking lives by adding one to counter after each guess
if(counter == 5) { //when the counter reaches x tries, user runs out of lives
points = wordLength; //this forcibly exits the while loop by satisfying the condition of points being equal to the number of letters
}
}
System.out.println("The word was " + inputWord); //prints the secret word
System.out.println("Game over"); //prints game over
}
public static void main(String[] args) {
ttt("barbarian");
}
}
I know it has to be a lot of effort to go through people's code, especially mine since it's so long and amateurish, so I did my best to comment out all my code to try to explain what I'm thinking. The hangman game is pretty much refined, and I am just trying to have it print the blanks but with guessed letters filled in.
So for example, the secret word is java
I guess j
output: j___
my code actually gets that far, but for any more guesses the output is just: ______
My question would be essentially, how do I get that for replacing loop to actually keep working after the first time?
Again, I want to thank everyone that answers in advance and again when I read them tomorrow morning.
At the first step, the program encounters the outer loop and executes its first iteration. This first iteration triggers, as a reaction, the inner nested loop, which then runs to completion. Then the program returns back to the top of the outer loop, completing the second iteration and again triggering the nested loop.
Nested loop means a loop statement inside another loop statement. That is why nested loops are also called as “loop inside loop“. Syntax for Nested Do-While loop: do{ do{ // statement of inside loop }while(condition); // statement of outer loop }while(condition);
It's a practice to avoid as much as possible because the number of nested loops and efficiency are directly connected. If you have 1 nested loop complexity of algorithm is on average O(n)2 and 2 nested loops complexity increase to O(n)3.
Nested loops are frequently (but not always) bad practice, because they're frequently (but not always) overkill for what you're trying to do. In many cases, there's a much faster and less wasteful way to accomplish the goal you're trying to achieve.
You are incorrectly building up tempList
.
In the second for-loop, for each used character, it adds all characters of allChars
to tempList
that do not match this specific used character. Besides the effect of adding duplicates in next iterations of the loop, this might also add characters that are already in usedChars
.
Change
ArrayList<String> tempList = new ArrayList<String>();
for(int i = 0; i < allChars.size(); i++) {
for(int k = 0; k < usedChars.size(); k++) {
if(!allChars.get(i).equals(usedChars.get(k))) {
tempList.add(allChars.get(i));
}
}
}
to
ArrayList<String> tempList = new ArrayList<String>();
for(int i = 0; i < allChars.size(); i++) {
if (!usedChars.contains(allChars.get(i))) {
tempList.add(allChars.get(i));
}
}
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With