Question

In PYTHON 3- Implement a subclass (described below) of "Word Guess", a variant of the game Hangman. In this game, a word is first randomly chosen. Initially, the letters in the word are displayed represented by "_”.  

For example, if the random word is "yellow”, the game initially displays "_ _ _ _ _ _”.

Then, each turn, the player guesses a single letter that has yet to be guessed. If the letter is in the secret word, then the corresponding "_” are replaced with the letter. If the letter appears more than once in the secret word, then "_” is replaced with the letter for each instance. For example, if the player guesses the letter "l”, then the game's progress will be updated to "_ _ l l _ _”.

TASK:

You will implement the WordGuess class in WordGuess.py. This class consists of the methods required to play a single Word Guess game. In the version of Word Guess you are creating, the allotted number of guesses is not constant. The allotted number of guesses is a function of the "edit distance” between the randomly chosen word and the alphabetically sorted random chosen word. The "edit distance” between two strings is the minimum number of insertions and deletions required to convert the first string into the second string. For example, the edit distance between "brain” and "crane” is 4:

1. Delete b at position 0

2. Insert c at position 0

3. Delete i at position 3

4. Insert e at position 4

Suppose the randomly chosen word is "brain”. When sorted, "brain” becomes "abinr”. The edit distance between "brain” and "abinr” is 4: abin

1. Insert a at position 0

2. Delete r at position 2

3. Delete a at position 2

4. Insert r at position 4

Once the edit distance is calculated, it is used to calculate the number of allotted guesses. The number of allotted guesses is bounded by the range [5,15] (inclusive). We set the number of allotted guesses to be 2*(edit distance). If this value is less than 5, then the number of allotted guesses is set to 5. If this value is greater than 15, then the number of allotted guesses is set to 15. Using this information, write the following methods:

• __init__(): Set the necessary attributes

• chooseSecretWord(): Randomly choose a secret word from the list of words read in from the input file

• editDistance(s1, s2): Returns the edit distance between s1 and s2, s1 being the string representations of the secret word and s2 the sorted secret word. Remember that the edit distance between s1 and s2 is the minimum number of insertions and deletions needed to convert s1 into s2. You must compute the edit distance using recursion.

• getGuess(): Asks the user to guess a letter they have yet to guess in the secret word. The game keeps querying the player for a letter until they enter a letter that hasn't been guessed yet. A class attribute will be needed to keep track of which letter have been guessed. The user may also enter the '*' character if they would like a hint that gives information about the secret word. If the user enters '*', they lose one of their allotted guesses.

• play(): Plays out a single full game of Word Guess. Initially, a secret word is chosen at random. Then, the edit distance is computed between the secret word and the sorted secret word. This edit distance is used to compute the number of allotted guesses. Then, while the player hasn't guessed the word and still has guesses available, the game progress is displayed, and the game queries the player for a guess. If the player correctly guesses a letter in the secret word, the number of allotted guesses remains the same. If the player enters a guess not in the secret word, the number of allotted guesses decrements by 1. If the user guesses a letter they have already guessed, they do not lose a guess. The game ends once the player has guessed all the letters in the secret word or has run out of guesses.

WordGuess.py TEMPLATE:

import random
from SecretWord import SecretWord

class WordGuess:

    def __init__(self, wordDic):
        #TODO

    def play(self):
        """ Plays out a single full game of Word Guess """
        #TODO

    def chooseSecretWord(self):
        """ Chooses the secret word that will be guessed """
        #TODO

    def editDistance(self, s1, s2):
        """ Recursively returns the total number of insertions and deletions required to convert S1 into S2 """
        #TODO

    def getGuess(self):
        """ Queries the user to guess a character in the secret word """
        #TODO

NOTE: SecretWord methods and their functionality are listed below. You do not have to implement these. The SecretWord class represents the randomly chosen word that is being guessed in the Word Guess game.

setWord(self, word):
    """ Adds the characters in 'word' to self.linkedList in the given order """

sort(self):
   """ Sorts the characters stored in self.linkedList in alphabetical order """

isSolved(self):
  """ Returns whether SecretWord has been solved (all letters in the word have been guessed by the user) """

update(self, guess):
    """ Updates the nodes in self.linkedList that match 'guess' """

printProgress(self):
    """ Prints the current game progress
    Ex: y _ l l _ w """

__str__(self):
    """ Converts the characters in self.linkedList into a string """

Answer 1

class Node:
def __init__(self, initData, initNext):
""" Constructs a new node and initializes it to contain
the given object (initData) and link to the given next node. """

self.data = initData
self.next = initNext

self.display = False

def getData(self):
""" Returns the element """
return self.data

def getNext(self):
""" Returns the next node """
return self.next

def getDisplay(self):
return self.display:

def setData(self, newData):
""" Sets newData as the element """
self.data = newData

def setNext(self, newNext):
""" Sets newNext as the next node """
self.next = newNext

def setDisplay(self, newDisplay):
self.display = newDisplay