def test_alphabetical(self): word_ladder = WordLadderPuzzle('mare', 'mire') # Should have 4 extensions: 'care', 'male', 'mars', 'mire', # in that order. exts = word_ladder.extensions() self.assertEqual(len(exts), 4) self.assertTrue(exts[-1].is_solved())
def test_word_ladder_eq_doctest() -> None: """Test WordLadder.__eq__ on the provided doctest""" wl1 = WordLadderPuzzle("me", "my", {"me", "my", "ma"}) wl2 = WordLadderPuzzle("me", "my", {"me", "my", "mu"}) wl3 = WordLadderPuzzle("me", "my", {"ma", "me", "my"}) assert wl1.__eq__(wl2) is False assert wl1.__eq__(wl3) is True
def test_no_duplicates(self): word_ladder = WordLadderPuzzle('mare', 'mire') exts = word_ladder.extensions() should_be_care = exts[0] # Only one extension: 'cars'. 'mare' should not be revisited. self.assertEqual(len(should_be_care.extensions()), 1) should_be_cars = should_be_care.extensions()[0] # 'cars' should extend to 'mars'. self.assertEqual(len(should_be_cars.extensions()), 1) should_be_mars = should_be_cars.extensions()[0] # 'mars' has no more extensions. self.assertEqual(len(should_be_mars.extensions()), 0)
def main(): """Prompt the user to configure and play the game. @rtype: None """ game = input("Do you want to play Sudoku (s) or Word Ladder (w)? ") while game != "s" and game != "w": print("That is not a valid input.") game = input( "Do you want to play Sudoku (s) or Word Ladder (w)? ").lower() if game == "s": view_type = "text" g = SudokuPuzzle([['', '', '', 'A'], ['D', '', 'B', ''], ['C', '', '', ''], ['', 'B', '', 'D']]) print( "\n\nTo make a move: use the format (<row>, <column>) -> letter.") elif game == "w": view_type = input( "Would you like to play in text mode or web mode? ").lower() if view_type != "web" and view_type != "text": print( "That is not a valid mode, you will be playing in text mode.") view_type = "text" choice = input( "Do you want to choose your start and end words? (y/n) ") if choice == "y": print( "Your starting and ending words should have the same length.") start = input("What would you like your starting word to be? ") end = input("What would you like your ending word to be? ") while len(start) != len(end): print( "Your starting and ending words don't have the same length. Please try again." ) start = input("What would you like your starting word to be? ") end = input("What would you like your ending word to be? ") else: start = "rock" end = "taco" g = WordLadderPuzzle(start, end) print( "\n\nTo make a move, type a word which does not differ by more than one letter from the current word." ) if view_type == "text": print("To quit the game, type exit.") print("To ask for a solution, type :SOLVE.") print("To ask for a hint, type :HINT.") print("To undo a move, type :UNDO.") print( "To look at your past moves from this current game state, type :ATTEMPTS.\n" ) c = Controller(g, mode=view_type)
def play_word_ladder(puz: WordLadderPuzzle) -> None: """ Simple text UI to play a given word ladder plus puzzle """ print("Controls:\n" "q to quit\n" "HINT for hint\n" "Good luck!\n") while not puz.is_solved(): next_word = input(f"{puz}\ntype your next word: ") if next_word == "q": return elif next_word == "HINT": puz = BfsSolver().solve(puz)[1] else: next_puzzle = WordLadderPuzzle(next_word, puz.to_word, puz.word_set) if next_puzzle in puz.extensions(): puz = next_puzzle else: print("invalid move, keep trying!\n" "q to quit\n" "HINT for hint\n") print("SOLVED!")
def test_word_ladder_get_difficulty() -> None: """Test WordLadder.get_difficulty on TRIVIAL and EASY puzzles.""" wl1 = WordLadderPuzzle("done", "done", {"done"}) assert wl1.get_difficulty() == TRIVIAL wl2 = WordLadderPuzzle("come", "done", {"come", "cone", "done"}) assert wl2.get_difficulty() == EASY
def make_word_ladder(difficulty: str = 'easy', target_word: str = 'cost', word_set: Optional[Set[str]] = None) -> \ Optional[WordLadderPuzzle]: """ Return a random WordLadderPlusPuzzle with the specified <difficulty> or None if there is no such puzzle. <difficulty> is one of 'easy' (default), 'medium', 'hard'. The other parameters are: <target_word> (default 'cost') - the word to use as the to_word <word_set> (default None) - the words to use in the WordLadderPuzzle (if None, uses load_words to use words from a file) The from_word is drawn randomly from word_set. Different from_words should be tried until either they have all been tried or a puzzle with the correct difficulty was found. Note: this is a rather inefficient way to do this (once you finish the assignment, you can try writing a smarter puzzle maker!) """ if word_set is None: word_set = load_words() my_words = list(word_set) shuffle(my_words) # try random from_words to make a puzzle for from_word in my_words: if len(from_word) == len(target_word): puz = WordLadderPuzzle(from_word, target_word, word_set) if puz.get_difficulty() == difficulty: return puz return None
def test_word_ladder_extensions_doctest() -> None: """Test WordLadder.__str__ on the provided doctest""" wl1 = WordLadderPuzzle("me", "my", {"me", "be", "my"}) wl2 = WordLadderPuzzle("be", "my", {"me", "be", "my"}) wl3 = WordLadderPuzzle("my", "my", {"me", "be", "my"}) msg1 = f"{wl1.extensions()} is missing some valid puzzle states" msg2 = f"{wl1.extensions()} contains extra invalid puzzle states" assert all([wlp in wl1.extensions() for wlp in [wl2, wl3]]), msg1 assert all([wlp in [wl2, wl3] for wlp in wl1.extensions()]), msg2
def test_invalid_word2(self): word_ladder = WordLadderPuzzle('mare', 'mire') with self.assertRaises(ValueError): # In dictionary, but not one letter away. word_ladder.move('cars')
def test_move_simple(self): word_ladder = WordLadderPuzzle('mare', 'mire') new_ladder = word_ladder.move('mire') self.assertTrue(new_ladder.is_solved())
def test_invalid_word1(self): word_ladder = WordLadderPuzzle('mare', 'mire') with self.assertRaises(ValueError): # Not in dictionary word_ladder.move('maze')
def test_solved_extension(self): word_ladder = WordLadderPuzzle('mire', 'mare') self.assertTrue(word_ladder.extensions()[0].is_solved())
print() return str(self._puzzle), self._puzzle.is_solved() except: return "Invalid action, please try again.", False else: # Parse the action to the puzzle and make the move try: value = self._puzzle.move(action) self._puzzle = value # add the state into the tree self._tree.act(action, self._puzzle) # return str(value), value.is_solved() except: return "Invalid action, please try again.", False if __name__ == '__main__': from sudoku_puzzle import SudokuPuzzle s = SudokuPuzzle([['', '', '', ''], ['', '', '', ''], ['C', 'D', 'A', 'B'], ['A', 'B', 'C', 'D']]) # c1 = Controller(s) from word_ladder_puzzle import WordLadderPuzzle w = WordLadderPuzzle("make", "cure") c2 = Controller(w)
def test_is_solved_start(self): word_ladder = WordLadderPuzzle('mist', 'mist') self.assertTrue(word_ladder.is_solved())
':UNDO', ':ATTEMPTS', ':UNDO', ':UNDO', ':ATTEMPTS', ':SOLVE' ], # If you omit the following filename, # the output will be printed to the console. # Otherwise, after you run the program, open # the new file to see the output. 'solved.txt') run_controller(s, [':HINT1', 'exit']) s = WordLadderPuzzle('mare', 'cars') run_controller(s, [ 'mare', ':ATTEMPTS', ':HINT 10', 'mire', ':UNDO', 'male', ':UNDO', ':ATTEMPTS', 'mars', 'cars' ]) s = WordLadderPuzzle('mars', 'mist') run_controller(s, [ 'mare', 'cars', ':HINT 10', ':UNDO', ':UNDO', 'mire', ':UNDO', ':ATTEMPTS', ':SOLVE' ]) s = SudokuPuzzle([['A', 'B', 'C', 'D'], ['', '', '', ''], ['', '', '', ''], ['', '', '', '']])
def test_word_ladder_str_doctest() -> None: """Test WordLadder.__str__ on the provided doctest""" wl1 = WordLadderPuzzle("me", "my", {"me", "my", "ma"}) wl2 = WordLadderPuzzle("me", "my", {"me", "my", "mu"}) assert str(wl1) == 'me -> my' assert str(wl2) == 'me -> my'
# not end return (self.state(), False) # otherwise else: # try following try: # get the current state of puzzleafter given move state = self._puzzle.move(action) # else the value error except ValueError as e: # return the string of e, and the program should not end return (str(e), False) # update the puzzle after move self._puzzle = state # get the puzzle state by finding the node of move from tree self._movetree.do(state, action) # return the current puzzle state # and check whether it has been solved return (self.state(), state.is_solved()) if __name__ == '__main__': from sudoku_puzzle import SudokuPuzzle s = SudokuPuzzle([['', '', '', ''], ['', '', '', ''], ['C', 'D', 'A', 'B'], ['A', 'B', 'C', 'D']]) c = Controller(s) from word_ladder_puzzle import WordLadderPuzzle s = WordLadderPuzzle('ye', 'ac') c = Controller(s)
def test_one_extensions(self): word_ladder = WordLadderPuzzle('mire', 'mare') self.assertEqual(len(word_ladder.extensions()), 1)
def test_no_extensions(self): word_ladder = WordLadderPuzzle('mist', 'mare') self.assertEqual(word_ladder.extensions(), [])
def test_is_not_solved_start(self): word_ladder = WordLadderPuzzle('mist', 'mare') self.assertFalse(word_ladder.is_solved())
def test_word_ladder_is_solved_doctest() -> None: """Test WordLadder.is_solved on the provided doctest""" wl1 = WordLadderPuzzle("me", "me", {"me", "my"}) wl2 = WordLadderPuzzle("me", "my", {"me", "my"}) assert wl1.is_solved() is True assert wl2.is_solved() is False
return "Already at a solution!" elif n == 1: if moves is []: return "No possible extensions!" else: for result in moves: if result.is_solved(): return True return moves[0] else: for i in moves: x = hint_by_depth(i, n-1) if x: return i elif x == i: return i if __name__ == '__main__': from word_ladder_puzzle import WordLadderPuzzle from sudoku_puzzle import SudokuPuzzle s = WordLadderPuzzle("mare","mist") for i in s.extensions(): print(i)