Are you overwhelmed and in need of C++ homework help now?

Undoubtedly, CodingZap is the best C++ homework help website on Internet. With having more than 9+ years of experience and backed by the most proficient Cpp coding experts, we are the best C++ assignment help website.

At Codingzap, we have a record of submitting the work before the deadline given.

Usually, it depends on the topic you have asked us to write about but mostly we deliver your assignments on time.

The price for getting C++ homework help starts at $30 and varies depending on the complexity of the assignment and the deadline. We always strive to offer affordable rates for students.

We strongly believe in providing the best CPP Programming Assignment Help to our students. We understand the pain you suffer while doing the assignment so we put the best experts in the work.

So, stop worrying and hire us for your C++ Homework Help now.

Writing C++ code could be challenging and worrisome for students who are beginners. Our experts at CodingZap follows the basic standard of writing the code. We always write C++ code from scratch and make sure they are well commented and written as per your rubric / instructions.

Here are the sample code written below to make you understand, ‘How we write the code for you?’

/*This is about Implement the Minimax-A-B algorithm using C++ programming language.*/

We are using Tic-Tac-Toe game to test the Minimax-A-B algorithm. You can see how code is being completed. Our codes are well-commented and written as per given requirements and instructions.

#include <iostream>
#include <vector>
#include <cstdlib>
#include <chrono>
#include <cmath>
#include <cstdlib>
#include <cstdio>
#include <climits>
#include <Windows.h>
#include <Psapi.h>
using namespace std;
char marker[3] ="OX";
char board[3][3] = {'_'};
int dx[4] = {-1,  0,  1, 1};
int dy[4] = {-1, -1, -1, 0};
int m_max_depth;
struct Coord
{
    int row;
    int col;
};

struct Moving
{
    int val;
    vector<Coord> path;
};
struct SearchResult
{
    Moving best_move;
    int generated_node;
    int expanded_node;
    chrono::milliseconds search_time;
}m_search_result;
void initialize(char b[3][3]);
void printBoard(char b[3][3], int pl);
int getState(char b[3][3]);
vector<Coord> move_gen(Coord position, int pl)
{
    vector<Coord> legal_move;
    vector<Coord> candidate;   
    for(int i = 0; i < 4; i++)
    {
        int cnt = 0;
        Coord temp;
        candidate.clear();
        for (int t = 0; t < 2; t++)
        {
            for(int k = 0; k < 2; k++)
            {
                temp.row = position.row + pow(-1, t) * dy[i] * (k + 1);
                temp.col = position.col + pow(-1, t) * dx[i] * (k + 1);
                if (temp.row > -1 && temp.row < 3 && temp.col > -1 && temp.col < 3)
                {
                    if (board[temp.row][temp.col] == '_')
                    {
                        candidate.push_back(temp);
                        cnt++;
                    }
                    else if (board[temp.row][temp.col] == marker[!pl])
                    {
                        cnt++;
                    }                    
                }               
            }
        }
        if (cnt == 2 )
        {          
            while (!candidate.empty())
            {
                legal_move.push_back(candidate.back());
                candidate.pop_back();
            }
        }
    }  
    return legal_move;
}
int Eval(Coord position, int pl)
{
    for (int row = 0; row<3; row++)
    {
        if (board[row][0]==board[row][1] && board[row][1]==board[row][2])
        {
            if (board[row][0]==marker[pl])
                return 100;
            else if (board[row][0]!=marker[pl])
                return -100;
        }
    }
 
    for (int col = 0; col<3; col++)
    {
        if (board[0][col]==board[1][col] && board[1][col]==board[2][col])
        {
            if (board[0][col]==marker[pl])
                return 100;
             else if (board[0][col]!=marker[pl])
                return -100;
        }
    }
 
    if (board[0][0]==board[1][1] && board[1][1]==board[2][2])
    {
        if (board[0][0]==marker[pl])
            return 100;
        else if (board[0][0]!=marker[pl])
            return -100;
    }
 
    if (board[0][2]==board[1][1] && board[1][1]==board[2][0])
    {
        if (board[0][2]==marker[pl])
            return 100;
        else if (board[0][2]!=marker[pl])
            return -100;
    }
    return 0;
}

int deep_enough(Coord position, int depth)
{
    if(getState(board))return true;
    return depth >= m_max_depth;
}
Moving minimax_A_B(Coord position, int depth, int pl, int ut, int pt)
{
    vector<Coord> best_path;
    if (deep_enough(position, depth)) 
    {
        return Moving{Eval(position, pl), {}};
    }
    vector<Coord> legal_move = move_gen(position, pl);
    ++m_search_result.expanded_node;
    m_search_result.generated_node += legal_move.size();

    if (legal_move.empty())
    {
        return Moving{Eval(position, pl), {}};
    }
    else
    {
        while (!legal_move.empty())
        {
            Coord succ = legal_move.back();
            legal_move.pop_back();
            Moving result_succ = minimax_A_B(succ, depth + 1, !pl, -1 * pt, -1 * ut);
            int new_val = -1 * result_succ.val;
            if (new_val > pt)
            {
                pt = new_val;
                best_path = result_succ.path;
                best_path.insert(best_path.begin(), succ);              
            }
            if (pt >= ut)
            {
                return Moving{pt, best_path};
            }
        }
        
    }
    
    return Moving{pt, best_path};
}

SearchResult findBestMove(Coord init_pos, int pl)
{
    m_search_result.expanded_node = 0;
    m_search_result.generated_node = 0;
    m_search_result.search_time = chrono::milliseconds::zero();

    auto time_0 = chrono::steady_clock::now();
    m_max_depth = 9;
    Moving m_result = minimax_A_B(init_pos, 0, pl, INT_MAX, -INT_MAX);
    auto time_1 = chrono::steady_clock::now();
    m_search_result.search_time = chrono::duration_cast<chrono::milliseconds>(time_1 - time_0);
    m_search_result.best_move = m_result;
    return m_search_result;
}
void initialize(char b[3][3])
{
    for(int i = 0; i < 3; i++)
    {
        for(int k = 0; k < 3; k++)
        {
            b[i][k] = '_';
        }
    }
}
int getState(char b[3][3])
{
    for (int row = 0; row<3; row++)
    {
        if (b[row][0]==b[row][1] && b[row][1]==b[row][2])
        {
            if (b[row][0]==marker[0])
                return +10;
            else if (b[row][0]==marker[1])
                return -10;
        }
    }
    for (int col = 0; col<3; col++)
    {
        if (b[0][col]==b[1][col] && b[1][col]==b[2][col])
        {
            if (b[0][col]==marker[0])
                return +10;
 
            else if (b[0][col]==marker[1])
                return -10;
        }
    }
    if (b[0][0]==b[1][1] && b[1][1]==b[2][2])
    {
        if (b[0][0]==marker[0])
            return +10;
        else if (b[0][0]==marker[1])
            return -10;
    }
    if (b[0][2]==b[1][1] && b[1][1]==b[2][0])
    {
        if (b[0][2]==marker[0])
            return +10;
        else if (b[0][2]==marker[1])
            return -10;
    }
    return 0;
}
bool isFinished(char b[3][3])
{
    if (getState(b))
    {
        return true;
    }  
    for (int i = 0; i < 3; i++)
        for (int k = 0; k < 3; k++)
            if (b[i][k]=='_')
                return false;
    return true;
}
Coord playGame(int pl)
{
    int best_val = -100;
    Coord best_move;
    best_move.row = -1;
    best_move.col = -1;
    for (int i = 0; i < 3; i++)
    {
        for (int k = 0; k < 3; k++)
        {
            if (board[i][k] == '_')
            {
                board[i][k] = marker[pl];
                SearchResult result = findBestMove(Coord{i, k}, pl);
                board[i][k] = '_';

                if(result.best_move.val > best_val)
                {
                    best_val = result.best_move.val;
                    if (result.best_move.path.size()!=0)
                    {
                        best_move = result.best_move.path.front();
                    }
                    else
                    {
                        best_move = Coord{i, k};
                    }         
                }
            }
        }
    }
    return best_move;   
}
float getCurrentMemoryUsage() 
{
	auto myHandle = GetCurrentProcess();
	PROCESS_MEMORY_COUNTERS pmc;
	::K32GetProcessMemoryInfo(myHandle, &pmc, sizeof(pmc));
	return pmc.WorkingSetSize / 1024. / 1024.;
}
void printBoard(char b[3][3], int pl)
{
    printf("Turn: %c\n",marker[pl]);
    for (int i = 0; i < 3; i++)
    {
        for (int k = 0; k < 3; k++)
        {
            printf("%2c ",b[i][k]);
            if (k != 2)
            {
                printf("|");
            }     
        }
        printf("\n");      
    }
    printf("Generated Node: %d nodes\n", m_search_result.generated_node);
    printf("Expanded Node: %d nodes\n", m_search_result.expanded_node);
    printf("Elapsed Time: %dms\n", m_search_result.search_time);
    printf("Total memory consumed %f(MB)\n", getCurrentMemoryUsage());
    printf("\n");
}
int main()
{
    //freopen("test.txt", "w", stdout);
    initialize(board);  
    int row = rand() % 11 % 3;
    int col = rand() % 12 % 3;
    int player = 0;
    board[row][col] = marker[player]; 
    printBoard(board, player);
    player = !player;
    while (!isFinished(board))
    {
        Coord pos = playGame(player);
        board[pos.row][pos.col] = marker[player];
        printBoard(board, player);
        player = !player;
    }
    return 0;
}