Forem: Dev Anand

Tic-tac-toe, Human vs Machine (AI)

Dev Anand — Sat, 11 Mar 2023 07:23:49 +0000

Ultimate challenge of human intelligence against artificial intelligence!

Today, we will witness a battle of wits between a human and an AI opponent in one of the simplest yet most beloved games of all time: Tic-Tac-Toe.

Tic-tac-toe and AI

Tic-Tac-Toe is a classic game that has been played by generations of children and adults alike. It's a game that is easy to learn, but difficult to master.

However, with the advent of AI (Artificial Intelligence), even the most skilled human players may find themselves struggling to keep up with their electronic counterparts.

It's important to first gain experience by coding the game to play against a human opponent.

Related Article: Tic-tac-toe, Human vs Human.

Keep calm coding begins....

Tic-tac-toe in Python

Grid box pattern

The game_grid(value) function takes a list value containing the current state of the Tic-Tac-Toe game board as input.

def game_grid(value):  
    print("\n")  
    print("\t____________________")  
    print("\t|      |      |     |")  
    print("\t|    {} |  {}   |  {}  |".format(value[0], value[1], value[2]))  
    print('\t|______|______|_____|')  
    print("\t|      |      |     |") 
    print("\t|   {}  |  {}   |  {}  |".format(value[3], value[4], value[5]))  
    print('\t|______|______|_____|')  
    print("\t|      |      |     |")  
    print("\t|  {}   |  {}   |  {}  |".format(value[6], value[7], value[8]))  
    print('\t|______|______|_____|')
    print("\n")

Possible winning patterns

The code defines a list called wining_pattern which contains sub-lists of all the possible winning combinations in a Tic-Tac-Toe game.

wining_pattern = [

    [1,2,3],
    [4,5,6],
    [7,8,9],
    [1,4,7],
    [2,5,8],
    [3,6,9],
    [1,5,9],
    [3,5,7]

]

Variables initialisation

These variables are used to keep track of the state of the game, including which positions on the board have been taken and by whom.

taken_moves = []
default_values = [' ' for i in range(9)]
players_moves = {
    'X_moves': [],
    'O_moves': []
}
players = ['X', 'O']

Update Game state

The update_game function updates the game state based on the player's move and returns a visual representation of the updated game board.

def update_game(move, player):
    taken_moves.append(move)
    players_moves[player + '_moves'].append(move)
    default_values[move - 1] = player
    return game_grid(default_values)

Decide winner

On the basis of taken steps, recorded inside players_moves dictionary, check_wining will decide the winner.

def check_wining(moves):
    for i in wining_pattern:
        if all(j in moves for j in i):
            return True 
    return False

How machine will play

AI First move

The initial_move() used to determine the first move made by the machine when playing tic-tac-toe against a human player.

def initial_move():
    #Acquire Center
    if 5 not in players_moves['X_moves']:
        return 5
    #Acquire any corner
    return random.choice([1,3,7,9])

AI Smart move 🤓

The smart_move() tries to find the best possible move for the player by analyzing the current state of the game and searching for potential winning slots.

def smart_move(mine_move, opp_moves):
    next_move = []
    for i in winning_pattern:
        if not [x for x in mine_move if x in i]:
            for j in i:
                if j not in opp_moves:
                    next_move.append(j)
            if len(next_move) == 1:
                return next_move[0]
            next_move = []
    return False

AI Winning move 🏆

The winning_move() checks if there is a possible winning move for the player and returns that move if there is, otherwise returns None.

def winning_move():
    moves = smart_move(players_moves['X_moves'], players_moves['O_moves'])
    return moves if moves else None

AI Random Edge move

The random_edge_move() returns the first available edge slot on the board, starting from the top-left and moving clockwise, if there is one.

def random_edge_move():
    for i in [2,4,6,8]:   
        if i not in taken_moves:
            return i

Driver Code - AI vs Human

It plays a game between a human player (X) and the computer (O), using a combination of pre-defined strategies and randomness to determine the computer's moves.

step = 0
game_grid(default_values)
while step < 9 and step >= 0:

    if step >= 4:
        print('Match tied!')
        break

    player = "X"
    try:
        move = int(input(player + " : "))
        if move < 10 and move not in taken_moves:
            step += 1
            update_game(move,player)
            winner = check_winning() if step > 1 else None
            if winner:
                print(winner, 'Won!')
                break
            elif step == 1:
                O_move = initial_move()
            else:
                O_move = winning_move()
                O_move = smart_move(players_moves['O_moves'], players_moves['X_moves']) if not O_move else O_move
                O_move = random_edge_move() if not O_move else O_move
            print("O (Python 🐍): ",O_move)
            player = "O"
            update_game(O_move, player)
            winner = check_winning() if step > 1 else None
            if winner:
                print(winner, 'Won!')
                break
            continue
        print("Invalid move! - either your move is too high or already taken.")
    except:
        print("Invalid move! - wrong input.")

Example testing

X = Human Player
O = AI (Computer)

I understand it's difficult at once, to understand the code, please refers: speakpython.codes/tic-tac-toe-human-vs-machine - for complete explanation.

This article is contributed by speakpython.codes

Hangman - classic word game

Dev Anand — Sat, 11 Mar 2023 07:13:22 +0000

Are you interested in creating a fun and interactive game in Python? If so, let's dive into building a Hangman game!

About Hangman

Hangman is a word guessing game where one player thinks of a word and the other player(s) try to guess it by suggesting letters.

The player(s) have a limited number of guesses and for each incorrect guess, a part of a hanging man is drawn.
The game continues until the player(s) either guess the word correctly or the hanging man is fully drawn, in which case the game is lost.

Keep calm coding begins....

Hangman in Python

Puzzle hint and answer

This code sets up the puzzle answer and hint for the Hangman game, which will be used later in the game to generate the puzzle and provide hints to the user.

from getpass import getpass
import math, random

string = getpass("\nProvide Puzzle Answer (Player 1) : ").strip().replace(" ", "").casefold()
hint = input('Any Hint : ')

Random and Custom Puzzle design

You can express the two ways of creating a puzzle for the Hangman game in your code

by providing the user with the option to either input their own word for the game
or have the game randomly select a word for them.

Random puzzle design

def auto_puzzle(puzzle, missing_words = ""):
    for i in range((len(puzzle)//2)):
        random_value = puzzle[math.floor(random.random()*len(puzzle))]
        if random_value not in missing_words:
            missing_words += random_value
    for a in range(len(puzzle)):
        if puzzle[a] in missing_words:
            puzzle = puzzle.replace(puzzle[a],'_')
    return puzzle, missing_words

Custom puzzle design

This function allows the user to manually select characters to be blanked out in the puzzle, and returns the updated puzzle and missing words to be used in the Hangman game.

def custom_puzzle(puzzle, missing_words = ""):
    num_blanks = int(input('How many blanks you prefer? : '))
    while len(missing_words) < num_blanks:
        blank_char = input('which character you want to blanked : ')
        if blank_char in puzzle:
            puzzle = puzzle.replace(blank_char,'_')
            missing_words += blank_char
            print(puzzle)
        else:
            print('Element not exist in Puzzle')
    return puzzle, missing_words

Validating Guesses

This function allows the user to make guesses for the missing characters in the puzzle and displays the updated puzzle string with correct guesses.

def check_for_guess(puzzle, string, missing_words):
    false_attempt = 0
    while false_attempt < len(missing_words):
        if puzzle == string.lower():
                break
        ask = 'Remain Attempt : {} | Guess a Word (unique) : '.format(len(missing_words)-(false_attempt))
        guess = input(ask).casefold()
        if guess in missing_words and len(guess) == 1:
            for a in range(len(puzzle)):
                if string[a].lower() == guess:
                    puzzle = puzzle[:a] + guess + puzzle[a+1:]
            print('Keep it on ',puzzle)
        else:
            false_attempt += 1
            print('Oops! Try again')
    return puzzle

Understanding the driver code

It creates a puzzle for the game based on user input. The code first sets the variable puzzle equal to the input string that represents the answer to the puzzle.

puzzle = string
if len(string) < 6:
    print('Answer should be > 6 characters')
else:
    false_attempt = 0
    puzzle_type = input('\nDo you want system designed puzzle? y/n : ')
    puzzle, missing_words = auto_puzzle(puzzle) if puzzle_type == 'y' or puzzle_type == 'Y' else custom_puzzle(puzzle)
    print('\n\nYour Puzzle (Player 2):',puzzle)
    print('Given hint: ',hint)
    given_answer = check_for_guess(puzzle, string, missing_words)
    print('\nCongratulation you won, Player 1 lost!') if given_answer == string.lower() else print('\nYou lost, Player 1 Won')

Let's play for fun

For complete explanation refers: speakpython.codes/hangman-word-game

This article is contributed by speakpython.codes

Expression Solver using #python

Dev Anand — Sun, 21 Aug 2022 08:34:43 +0000

After running the👆🏻 program in your machine

Provide a valid expression

Press Enter to have your result.

⚠️⚠️ This program is not following the BODMAS approach (mathematics), it provides the result just like your calculator operations.

🚀 DownTube - Content Downloader

Dev Anand — Thu, 21 Jul 2022 14:21:00 +0000

It is a free-to-use - content downloader service that works upon many open source APIs.

💫 Features

Using the shared 🔗 link, now you can download

YouTube Video + Shorts
YouTube Music + Spotify Song + Apple Music

100% Free + Unlimited downloads with No Ads 🤯.

Built with Fast and Safe nature.

100% responsive design.

🔨 Tools used

Front-end language used HTML, CSS and JavaScript.
Backend language used Django framework (Python) and SQL for -database.
File handling using Python.
List of APIs used:
Google APIs
Spotify APIs
And many other python unofficial APIs.

Source Code: https://github.com/dev3058/downtube-web-app

Check out: 🤔 How 🚀 DownTube Download is better than Spotify

Developer Zone

Hello_World 👋, Welcome to our blog - Developer Zone, here we post about 👨‍💻 development & many amazing facts.

blog.3058.in