Explain?
# Function to print Tic Tac Toe
def print_tic_tac_toe(values):
print("\n")
print("\t | |")
print("\t {} | {} | {}".format(values[0], values[1], values[2]))
print('\t_____|_____|_____')
print("\t | |")
print("\t {} | {} | {}".format(values[3], values[4], values[5]))
print('\t_____|_____|_____')
print("\t | |")
print("\t {} | {} | {}".format(values[6], values[7], values[8]))
print("\t | |")
print("\n")
# Function to print the score-board
def print_scoreboard(score_board):
print("\t--------------------------------")
print("\t SCOREBOARD ")
print("\t--------------------------------")
players = list(score_board.keys())
print("\t ", players[0], "\t ", score_board[players[0]])
print("\t ", players[1], "\t ", score_board[players[1]])
print("\t--------------------------------\n")
# Function to check if any player has won
def check_win(player_pos, cur_player):
# All possible winning combinations
soln = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [1, 4, 7], [2, 5, 8], [3, 6, 9], [1, 5, 9], [3, 5, 7]]
# Loop to check if any winning combination is satisfied
for x in soln:
if all(y in player_pos[cur_player] for y in x):
# Return True if any winning combination satisfies
return True
# Return False if no combination is satisfied
return False
# Function to check if the game is drawn
def check_draw(player_pos):
if len(player_pos['X']) + len(player_pos['O']) == 9:
return True
return False
# Function for a single game of Tic Tac Toe
def single_game(cur_player):
# Represents the Tic Tac Toe
values = [' ' for x in range(9)]
# Stores the positions occupied by X and O
player_pos = {'X':[], 'O':[]}
# Game Loop for a single game of Tic Tac Toe
while True:
print_tic_tac_toe(values)
# Try exception block for MOVE input
try:
print("Player ", cur_player, " turn. Which box? : ", end="")
move = int(input())
except ValueError:
print("Wrong Input!!! Try Again")
continue
# Sanity check for MOVE inout
if move < 1 or move > 9:
print("Wrong Input!!! Try Again")
continue
# Check if the box is not occupied already
if values[move-1] != ' ':
print("Place already filled. Try again!!")
continue
# Update game information
# Updating grid status
values[move-1] = cur_player
# Updating player positions
player_pos[cur_player].append(move)
# Function call for checking win
if check_win(player_pos, cur_player):
print_tic_tac_toe(values)
print("Player ", cur_player, " has won the game!!")
print("\n")
return cur_player
# Function call for checking draw game
if check_draw(player_pos):
print_tic_tac_toe(values)
print("Game Drawn")
print("\n")
return 'D'
# Switch player moves
if cur_player == 'X':
cur_player = 'O'
else:
cur_player = 'X'
if __name__ == "__main__":
print("Player 1")
player1 = input("Enter the name : ")
print("\n")
print("Player 2")
player2 = input("Enter the name : ")
print("\n")
# Stores the player who chooses X and O
cur_player = player1
# Stores the choice of players
player_choice = {'X' : "", 'O' : ""}
# Stores the options
options = ['X', 'O']
# Stores the scoreboard
score_board = {player1: 0, player2: 0}
print_scoreboard(score_board)
# Game Loop for a series of Tic Tac Toe
# The loop runs until the players quit
while True:
# Player choice Menu
print("Turn to choose for", cur_player)
print("Enter 1 for X")
print("Enter 2 for O")
print("Enter 3 to Quit")
# Try exception for CHOICE input
try:
choice = int(input())
except ValueError:
print("Wrong Input!!! Try Again\n")
continue
# Conditions for player choice
if choice == 1:
player_choice['X'] = cur_player
if cur_player == player1:
player_choice['O'] = player2
else:
player_choice['O'] = player1
elif choice == 2:
player_choice['O'] = cur_player
if cur_player == player1:
player_choice['X'] = player2
else:
player_choice['X'] = player1
elif choice == 3:
print("Final Scores")
print_scoreboard(score_board)
break
else:
print("Wrong Choice!!!! Try Again\n")
# Stores the winner in a single game of Tic Tac Toe
winner = single_game(options[choice-1])
# Edits the scoreboard according to the winner
if winner != 'D' :
player_won = player_choice[winner]
score_board[player_won] = score_board[player_won] + 1
print_scoreboard(score_board)
# Switch player who chooses X or O
if cur_player == player1:
cur_player = player2
else:
cur_player = player1
Answers
Answer:
# टिक टीएसी को पैर की अंगुली प्रिंट करने का कार्य Function
def print_tic_tac_toe (मान):
प्रिंट ("\ n")
प्रिंट ("\ t | |")
प्रिंट ("\ t} | {} | {}". प्रारूप (मान [0], मान [1], मान [2]))
प्रिंट ('\ t _____ | _____ | _____')
प्रिंट ("\ t | |")
प्रिंट ("\ t} | {} | {}". प्रारूप (मान [3], मान [4], मान [5]))
प्रिंट ('\ t _____ | _____ | _____')
प्रिंट ("\ t | |")
प्रिंट ("\ t} |}} |}}". प्रारूप (मान [6], मान [7], मान [8]))
प्रिंट ("\ t | |")
प्रिंट ("\ n")
# स्कोर-बोर्ड प्रिंट करने का कार्य
डीईएफ़ प्रिंट_स्कोरबोर्ड (स्कोर_बोर्ड):
प्रिंट ("\ t ---------------------------------"))
प्रिंट ("\ t स्कोरबोर्ड")
प्रिंट ("\ t ---------------------------------"))
खिलाड़ी = सूची (score_board.keys ())
प्रिंट ("\ t", खिलाड़ी [0], "\ t", स्कोर_बोर्ड [खिलाड़ी [0]])
प्रिंट ("\ t", खिलाड़ी [1], "\ t", Score_board [खिलाड़ी [1]])
प्रिंट ("\ t --------------------------------- \ n")
# यह जांचने का कार्य कि क्या कोई खिलाड़ी जीता है
def check_win (player_pos, cur_player):
# सभी संभावित विजेता संयोजन
सोलन = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [1, 4, 7], [2, 5, 8], [3, 6, 9] , [१, ५, ९], [३, ५, ७]]
# यह जांचने के लिए लूप करें कि क्या कोई विजेता संयोजन संतुष्ट है
सोल में एक्स के लिए:
यदि सभी (y in player_pos [cur_player] y in x के लिए):
# यदि कोई विजेता संयोजन संतुष्ट करता है तो सही लौटें
रिटर्न ट्रू
# यदि कोई संयोजन संतुष्ट नहीं है तो गलत लौटें
विवरण झूठा है
# खेल ड्रा हुआ है या नहीं यह जांचने के लिए कार्य
def check_draw (player_pos):
अगर लेन (player_pos ['X']) + लेन (player_pos ['O']) == 9:
रिटर्न ट्रू
विवरण झूठा है
# टिक टीएसी को पैर की अंगुली के एकल खेल के लिए कार्य
डीईएफ़ सिंगल_गेम (cur_player):
# टिक टीएसी को पैर की अंगुली का प्रतिनिधित्व करता है
मान = ['' श्रेणी में x के लिए (9)]
# एक्स और ओ के कब्जे वाले पदों को स्टोर करता है
प्लेयर_पोस = {'एक्स': [], 'ओ': []
# टिक टीएसी को पैर की अंगुली के एकल गेम के लिए गेम लूप
जबकि सच:
print_tic_tac_toe (मान)
# मूव इनपुट के लिए अपवाद ब्लॉक का प्रयास करें
प्रयत्न:
प्रिंट ("खिलाड़ी", cur_player, "बारी। कौन सा बॉक्स?:", अंत = "")
चाल = int (इनपुट ())
ValueError को छोड़कर:
प्रिंट ("गलत इनपुट !!! पुन: प्रयास करें")
जारी रखें
# MOVE inout के लिए सैनिटी चेक
अगर मूव <1 या मूव> 9:
प्रिंट ("गलत इनपुट !!! पुन: प्रयास करें")
जारी रखें
# जांचें कि क्या बॉक्स पहले से ही भरा हुआ नहीं है
यदि मान [चाल -1]! = '':
प्रिंट ("स्थान पहले ही भर चुका है। पुनः प्रयास करें !!")
जारी रखें
# गेम की जानकारी अपडेट करें
# ग्रिड की स्थिति अपडेट करना
मान [चाल -1] = cur_player
# खिलाड़ी की स्थिति अपडेट करना
Player_pos [cur_player] .append (स्थानांतरित करें)
# जीत की जाँच के लिए फंक्शन कॉल
अगर check_win (player_pos, cur_player):
print_tic_tac_toe (मान)
प्रिंट ("खिलाड़ी", cur_player, "गेम जीत लिया है !!")
प्रिंट ("\ n")
वापसी cur_player
# ड्रॉ गेम चेक करने के लिए फंक्शन कॉल
अगर check_draw (player_pos):
print_tic_tac_toe (मान)
प्रिंट ("गेम ड्रॉ")
प्रिंट ("\ n")
वापसी 'डी'
# स्विच प्लेयर चलता है
अगर cur_player == 'X':
cur_player = 'ओ'
अन्य:
cur_player = 'एक्स'
अगर __name__ == "__main__":
प्रिंट ("प्लेयर 1")
खिलाड़ी 1 = इनपुट ("नाम दर्ज करें:")
प्रिंट ("\ n")
प्रिंट ("प्लेयर 2")
खिलाड़ी 2 = इनपुट ("नाम दर्ज करें:")
प्रिंट ("\ n")
# X और O को चुनने वाले खिलाड़ी को स्टोर करता है
cur_player = खिलाड़ी1
#खिलाड़ियों की पसंद को स्टोर करता है
प्लेयर_चॉइस = {'एक्स': "", 'ओ': ""
# विकल्प स्टोर करता है
विकल्प = ['एक्स', 'ओ']
# स्कोरबोर्ड स्टोर करता है
स्कोर_बोर्ड = {खिलाड़ी1:0,खिलाड़ी2:0
प्रिंट_स्कोरबोर्ड (स्कोर_बोर्ड)
# टिक टीएसी को पैर की अंगुली की एक श्रृंखला के लिए गेम लूप
# लूप तब तक चलता है जब तक खिलाड़ी बाहर नहीं निकल जाते
जबकि सच:
#खिलाड़ी पसंद मेनू
प्रिंट ("चुनने के लिए बारी", cur_player)
प्रिंट ("एक्स के लिए 1 दर्ज करें")
प्रिंट ("ओ के लिए 2 दर्ज करें")
प्रिंट ("छोड़ने के लिए 3 दर्ज करें")
# चॉइस इनपुट के लिए अपवाद का प्रयास करें
प्रयत्न:
पसंद = int (इनपुट ())
ValueError को छोड़कर:
प्रिंट ("गलत इनपुट !!! पुन: प्रयास करें \ n")
जारी रखें
#खिलाड़ी की पसंद के लिए शर्तें
अगर पसंद == 1:
प्लेयर_चॉइस ['एक्स'] = cur_player
अगर cur_player == खिलाड़ी1:
प्लेयर_चॉइस ['ओ'] = प्लेयर2
अन्य:
प्लेयर_चॉइस ['ओ'] = प्लेयर1
एलिफ पसंद == 2:
प्लेयर_चॉइस ['ओ'] = cur_player
अगर cur_player == खिलाड़ी1:
प्लेयर_चॉइस ['एक्स'] = प्लेयर2
अन्य:
प्लेयर_चॉइस ['एक्स'] = प्लेयर1
एलिफ पसंद == 3:
प्रिंट ("अंतिम स्कोर")
प्रिंट_स्कोरबोर्ड (स्कोर_बोर्ड)
टूटना
अन्य:
प्रिंट ("गलत विकल्प !!!! पुन: प्रयास करें \ n")
# टिक टीएसी को पैर की अंगुली के एक ही गेम में विजेता को स्टोर करता है
विजेता = सिंगल_गेम (विकल्प [विकल्प -1])
# विजेता के अनुसार स्कोरबोर्ड संपादित करता है
अगर विजेता! = 'डी':
प्लेयर_वोन = प्लेयर_चॉइस [विजेता]
स्कोर_बोर्ड [खिलाड़ी_वोन] = स्कोर_बोर्ड [खिलाड़ी_वोन] + 1
प्रिंट_स्कोरबोर्ड (स्कोर_बोर्ड)
# स्विच प्लेयर जो एक्स या ओ . चुनता है
अगर cur_player == खिलाड़ी1:
cur_player = खिलाड़ी2
अन्य:
cur_player = खिलाड़ी1