# TicTacToe import random def drwBoard(bo): # method prints the board print(\' |

ID: 674424 • Letter: #

Question

# TicTacToe

import random

def drwBoard(bo):

# method prints the board

def inputPlayerChar():

# myplayer should type the character, he they need to be.

ch = ''

while not (ch == 'X' or ch == 'O'):

print('Do you need to be X/O?')

ch = input().upper()

# the first character is the myplayer's, the second character is the computer's.

if ch == 'X':

return ['X', 'O']

else:

return ['O', 'X']

def whoFirstGo():

# this will choose randomly choose amoung players who has to go first.

if random.randint(0, 1) == 0:

return 'mycomputer'

else:

return 'myplayer'

def playOnceAgain():

# This method will return True if myplayer wishes to play once again.

# else the method will return not True.

print('Do you need to play once again? (yes / no)')

return input().lower().startswith('y')

def makeaMove(bo, ch, mov):

bo[mov] = ch

def winner(b, c):

# Provided board and myplayer's character, this method returns True if that he won.

# We use b instead of board and c instead of character

return ((b[7] == c and b[8] == c and b[9] == c) or

# across top

(b[4] == c and b[5] == c and b[6] == c) or

# across middle

(b[1] == c and b[2] == c and b[3] == c) or

# across bottom

(b[7] == c and b[4] == c and b[1] == c) or

# down left

(b[8] == c and b[5] == c and b[2] == c) or

# down middle

(b[9] == c and b[6] == c and b[3] == c) or

# down right side

(b[7] == c and b[5] == c and b[3] == c) or

# diagonals

(b[9] == c and b[5] == c and b[1] == c))

# diagonals

def getCopyBoard(bo):

# Make a copy of board

# return it is a copy.

copyBoard = []

for a in bo:

copyBoard.append(a)

return copyBoard

def isFreeSpace(bo, mov):

# Return true if passed mov is free apot on passed board.

return bo[mov] == ' '

def getPlayersMove(bo):

# Let myplayer type in mov.

mov = ' '

while mov not in '1 2 3 4 5 6 7 8 9'.split() or not isFreeSpace(bo, int(mov)):

print('you next mov?(1-9)')

mov = input()

return int(mov)

def chooseRandomMove(bo, movList):

# Return a valid mov from the passed on passed board.

# Return None if there isn't any valid mov.

possibleMov = []

for a in movList:

if isFreeSpace(bo, a):

possibleMov.append(a)

if len(possibleMov) != 0:

return random.choice(possibleMov)

else:

return None

def getComputerMov(bo, computerCh):

# Provided board and mycomputer's character, decide where to mov & return the mov.

if computerCh == 'X':

playerCh = 'O'

else:

playerCh = 'X'

# Algorithm for TicTacToe:

# First, verify if he wins in next mov

for a in range(1, 10):

mycopy = getCopyBoard(bo)

if isFreeSpace(mycopy, a):

makeaMove(mycopy, computerCh, a)

if winner(mycopy, computerCh):

return a

# Checking if myplayer wins on next mov, and block him.

for a in range(1, 10):

mycopy = getCopyBoard(bo)

if isFreeSpace(mycopy, a):

makeaMove(mycopy, playerCh, a)

if winner(mycopy, playerCh):

return a

# Trying to fill 1 of the corner spots, if free.

mov = chooseRandomMove(bo, [1, 3, 7, 9])

if mov != None:

return mov

# Trying to fill center position , if free.

if isFreeSpace(bo, 5):

return 5

# Move on 1 of the sides.

return chooseRandomMove(bo, [2, 4, 6, 8])

def isFullBoard(bo):

# Return True if each space on board has been utilized.

# else return not True.

for a in range(1, 10):

if isFreeSpace(bo, a):

return False

return True

print('TicTacToe!')

while True:

# Reset board

board = [' '] * 10

playerCh, computerCh = inputPlayerChar()

play = whoFirstGo()

print('The ' + play + ' will be going first!')

gamePlay = True

while gamePlay:

if play == 'myplayer':

# Player's play.

drwBoard(board)

mov = getPlayersMove(board)

makeaMove(board, playerCh, mov)

if winner(board, playerCh):

drwBoard(board)

print('You won!')

gamePlay = False

else:

if isFullBoard(board):

drwBoard(board)

print('Tie game!')

break

else:

play = 'mycomputer'

#else:

# It's Computer's play.

mov = getComputerMov(board, computerCh)

makeaMove(board, computerCh, mov)

if winner(board, computerCh):

drwBoard(board)

print('You Lose! The computer won!')

gamePlay = False

else:

if isFullBoard(board):

drwBoard(board)

print('Tie game!')

break

else:

play = 'myplayer'

if not playOnceAgain():

break

In Python, write a tic-tac-toe game that allows a human player to play against the computer. Your program will play many turns against a human opponent, and it will learn. When it is the computer's turn, the computer randomly selects an empty field, except that it won't ever choose a losing combination. For that purpose, your program must keep an array of losing combinations. Whenever the human wins, the immediately preceding combination is stored as losing. For example, suppose that X- computer and 0- human. Suppose the current combination is Now, it is the human's turn, who will of course choose 0 0 The computer should then remember the preceding combination as a losing combination. As a result, the computer will never again choose a combination from 0 or 0 Your program will be graded based on the following rubric

Explanation / Answer

Please save the below code wth .py extension and compile it.

---------------------------------------------

import random

def drawBoard(board):
# This function prints out the board that it was passed.

# "board" is a list of 10 strings representing the board (ignore index 0)

print(' | |')

print(' ' + board[7] + ' | ' + board[8] + ' | ' + board[9])

print(' | |')

print('-----------')

print(' | |')

print(' ' + board[4] + ' | ' + board[5] + ' | ' + board[6])

print(' | |')

print('-----------')
print(' | |')

print(' ' + board[1] + ' | ' + board[2] + ' | ' + board[3])
print(' | |')

def inputPlayerLetter():

# Lets the player type which letter they want to be.

# Returns a list with the player’s letter as the first item, and the computer's letter as the second.

letter = ''

while not (letter == 'X' or letter == 'O'):

print('Do you want to be X or O?')

letter = input().upper()

# the first element in the list is the player’s letter, the second is the computer's letter.

if letter == 'X':

return ['X', 'O']

else:

return ['O', 'X']

def whoGoesFirst():
# Randomly choose the player who goes first.

if random.randint(0, 1) == 0:

return 'computer'

else:

return 'player'

def playAgain():

# This function returns True if the player wants to play again, otherwise it returns False.

print('Do you want to play again? (yes or no)')

return input().lower().startswith('y')

def makeMove(board, letter, move):

board[move] = letter
def isWinner(bo, le):

# Given a board and a player’s letter, this function returns True if that player has won.

# We use bo instead of board and le instead of letter so we don’t have to type as much.

return ((bo[7] == le and bo[8] == le and bo[9] == le) or # across the top

     (bo[4] == le and bo[5] == le and bo[6] == le) or # across the middle
     (bo[1] == le and bo[2] == le and bo[3] == le) or # across the bottom
   (bo[7] == le and bo[4] == le and bo[1] == le) or # down the left side

(bo[8] == le and bo[5] == le and bo[2] == le) or # down the middle

(bo[9] == le and bo[6] == le and bo[3] == le) or # down the right side

(bo[7] == le and bo[5] == le and bo[3] == le) or # diagonal

(bo[9] == le and bo[5] == le and bo[1] == le)) # diagonal

def getBoardCopy(board):

# Make a duplicate of the board list and return it the duplicate.

dupeBoard = []

for i in board:

dupeBoard.append(i)

return dupeBoard

def isSpaceFree(board, move):

# Return true if the passed move is free on the passed board.

return board[move] == ' '

def getPlayerMove(board):

# Let the player type in their move.
move = ' '

while move not in '1 2 3 4 5 6 7 8 9'.split() or not isSpaceFree(board, int(move)):

print('What is your next move? (1-9)')

move = input()

return int(move)

def chooseRandomMoveFromList(board, movesList):

# Returns a valid move from the passed list on the passed board.

# Returns None if there is no valid move.

possibleMoves = []

for i in movesList:

if isSpaceFree(board, i):

possibleMoves.append(i)

if len(possibleMoves) != 0:

return random.choice(possibleMoves)

else:

return None

def getComputerMove(board, computerLetter):

# Given a board and the computer's letter, determine where to move and return that move.

if computerLetter == 'X':

playerLetter = 'O'

else:

playerLetter = 'X'

# Here is our algorithm for our Tic Tac Toe AI:

# First, check if we can win in the next move

for i in range(1, 10):

copy = getBoardCopy(board)

if isSpaceFree(copy, i):

makeMove(copy, computerLetter, i)

if isWinner(copy, computerLetter):

return i

# Check if the player could win on their next move, and block them.

for i in range(1, 10):

copy = getBoardCopy(board)

if isSpaceFree(copy, i):

makeMove(copy, playerLetter, i)

if isWinner(copy, playerLetter):

return i

# Try to take one of the corners, if they are free.

move = chooseRandomMoveFromList(board, [1, 3, 7, 9])

if move != None:

return move

# Try to take the center, if it is free.

if isSpaceFree(board, 5):

return 5

# Move on one of the sides.

return chooseRandomMoveFromList(board, [2, 4, 6, 8])

def isBoardFull(board):

# Return True if every space on the board has been taken. Otherwise return False.

for i in range(1, 10):

if isSpaceFree(board, i):

return False

return True

print('Welcome to Tic Tac Toe!')

while True:

# Reset the board

theBoard = [' '] * 10

playerLetter, computerLetter = inputPlayerLetter()

turn = whoGoesFirst()

print('The ' + turn + ' will go first.')

gameIsPlaying = True

while gameIsPlaying:

if turn == 'player':

# Player’s turn.

drawBoard(theBoard)

move = getPlayerMove(theBoard)

makeMove(theBoard, playerLetter, move)

if isWinner(theBoard, playerLetter):

drawBoard(theBoard)

print('Hooray! You have won the game!')

gameIsPlaying = False

else:

if isBoardFull(theBoard):
drawBoard(theBoard)

print('The game is a tie!')
break

else:

turn = 'computer'

else:
# Computer’s turn.

move = getComputerMove(theBoard, computerLetter)

makeMove(theBoard, computerLetter, move)

if isWinner(theBoard, computerLetter):

drawBoard(theBoard)

print('The computer has beaten you! You lose.')

gameIsPlaying = False

else:

if isBoardFull(theBoard):

drawBoard(theBoard)

print('The game is a tie!')

break

else:

turn = 'player'

if not playAgain():

break

Navigate

# This program uses a Python dictionary to find the mode(s) of a data set. # The

# Two identical plants are grown in two pots in the greenhouse. The pots are ide

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.

# TicTacToe import random def drwBoard(bo): # method prints the board print(\' |

Question

Explanation / Answer

Related Questions

Navigate