I think you’re misunderstanding the insert method. insert keeps everything that was already in the list, including the item at the given index. it just shifts part of it to the right to make room for the thing you’re inserting. Directly changing the list using display[position] = letter instead replaces the item at the index with letter.

Does that make sense?

Having the output of each thing you tried would help us get a feel for where your code was messing up without us having to run it ourselves to get the output.

That said, for code snippet 1, you’re inserting the letter instead of replacing the underscore with the letter. Not only that, but your for-loop essentially does the following:

• loop over the length of chosen_word
• if guess is in the above loop
  • iterate over the display array and add guess that many times (effectively doubling the `display array)

Your second code snippet does the same thing, but with actual formatting so that Python could run the code.

I believe your third code snippet introduces char but then returns to letter. It might work if you replaced char with letter again. Also += letter will add the letter to the end of display, which is not what you want to do.

I did my own version of Hangman in Python a couple years ago if you want to look at the code and see what I did. I’m just a hobbyist, so it’s not fantastic, but it might give you an idea of how someone else has approached the problem.

Don’t forget Python’s amazing list comprehension syntax!

guess = input(“Guess a letter:”).lower()
display = [ letter if letter == guess else “_” for letter in word ]

Just one part of your question, but it saves a lot of futzing around with indices and replaces.

I think what tripped you up here is that you iterated over the wrong object. In your second solution:

for letter in chosen_word:
  if guess == letter:
    for i in range(len(chosen_word[letter])):
      display.insert(i, guess)

while in the correct solution:

for position in range(word_length):
  letter = chosen_word[position]
  if letter == guess:
    display[position] = letter

The most important difference here is that in your code block, you iterate over the letters, ie. 'a', 'a', 'r', ..., while in the second you iterate over the numerical indices of the string, 0, 1, 2, .... In this specific use case, it’s much easier to use the numerical indices - because you can see how the second code block is using position in two places - once to retrieve the letter from the solution, and then again to update the display when the if condition matches.

Usually we prefer iteration using the method you used in your solution. But in this case, it’s easier to just iterate by index because you’re retrieving the element from one string, and updating the same position in the other string. You have no way of knowing what position to modify in display unless you have the numerical position, so it’s much easier to iterate that way in this case.

This is a pretty compact and - I think - easy to read way of doing it:

while(display != list(chosen_word)):

guess = input("Guess a letter: ").lower()

display = list(map(lambda c, d: c if d != '_' or c == guess else d, chosen_word, display))

print(display)

print("Congrats! You did it!")

Mapping over an array is a pretty powerful tool and also using ternary expressions. If you’re not familiar, a map basically just iterates over an array and runs a function on that item, replacing it with whatever the return value of the function is.

For example:

ones = [1, 1] twos = list(map(lambda n: n + 1, ones))

It’s running the lambda function with n as a parameter and returning n + 1, and it’s pulling the numbers from the array “ones”.

Then ternary expressions I also find quite powerful. The format of which is basically:

(result if true) if (condition to check) else (result of false)

Or:

2 if 1 + 1 == 2 else "You broke math. How did you do that?"