C++ Projects – Page 2 – Projects Inventory

Simulation of Genetic Drift Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <algorithm>

const int POPULATION_SIZE = 100;
const int GENERATIONS = 50;
const int INITIAL_A = 50;  // Initial number of A alleles
const int INITIAL_B = 50;  // Initial number of B alleles

class Population {
public:
    Population() {
        alleles.resize(POPULATION_SIZE, 'A');
        std::fill(alleles.begin(), alleles.begin() + INITIAL_A, 'A');
        std::fill(alleles.begin() + INITIAL_A, alleles.end(), 'B');
        std::random_shuffle(alleles.begin(), alleles.end());
    }

    void simulateGeneration() {
        std::vector<char> newAlleles(POPULATION_SIZE);
        for (int i = 0; i < POPULATION_SIZE; ++i) {
            newAlleles[i] = alleles[std::rand() % POPULATION_SIZE];
        }
        alleles = newAlleles;
    }

    void printStatistics() const {
        int countA = std::count(alleles.begin(), alleles.end(), 'A');
        int countB = std::count(alleles.begin(), alleles.end(), 'B');
        std::cout << "A alleles: " << countA << ", B alleles: " << countB << '\n';
    }

private:
    std::vector<char> alleles;
};

int main() {
    std::srand(static_cast<unsigned>(std::time(0)));

    Population population;

    std::cout << "Initial population:\n";
    population.printStatistics();

    for (int generation = 1; generation <= GENERATIONS; ++generation) {
        population.simulateGeneration();
        std::cout << "Generation " << generation << ":\n";
        population.printStatistics();
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <cstdlib>

#include <ctime>

#include <algorithm>

const int POPULATION_SIZE = 100;

const int GENERATIONS = 50;

const int INITIAL_A = 50; // Initial number of A alleles

const int INITIAL_B = 50; // Initial number of B alleles

class Population {

public:

Population() {

alleles.resize(POPULATION_SIZE, 'A');

std::fill(alleles.begin(), alleles.begin() + INITIAL_A, 'A');

std::fill(alleles.begin() + INITIAL_A, alleles.end(), 'B');

std::random_shuffle(alleles.begin(), alleles.end());

}

void simulateGeneration() {

std::vector<char> newAlleles(POPULATION_SIZE);

for (int i = 0; i < POPULATION_SIZE; ++i) {

newAlleles[i] = alleles[std::rand() % POPULATION_SIZE];

}

alleles = newAlleles;

}

void printStatistics() const {

int countA = std::count(alleles.begin(), alleles.end(), 'A');

int countB = std::count(alleles.begin(), alleles.end(), 'B');

std::cout << "A alleles: " << countA << ", B alleles: " << countB << '\n';

}

private:

std::vector<char> alleles;

};

int main() {

std::srand(static_cast<unsigned>(std::time(0)));

Population population;

std::cout << "Initial population:\n";

population.printStatistics();

for (int generation = 1; generation <= GENERATIONS; ++generation) {

population.simulateGeneration();

std::cout << "Generation " << generation << ":\n";

population.printStatistics();

}

return 0;

}

Explanation Class Definition (Population): Private Members: alleles: A vector storing the alleles in the population (‘A’ or ‘B’). Public Methods: Population(): Constructor initializes the population with INITIAL_A ‘A’ alleles and INITIAL_B ‘B’ alleles. Shuffles the alleles to randomize their order. void simulateGeneration(): Simulates genetic drift by randomly selecting alleles to form the new generation. …

Simulation of Genetic Drift Gaming Project in C++ Read More »

Simulation of Game Theory Strategies Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>

enum Choice { COOPERATE, DEFECT };

class Player {
public:
    Player(std::string name) : name(name), score(0) {}

    void makeChoice(Choice choice) {
        this->choice = choice;
    }

    Choice getChoice() const {
        return choice;
    }

    void updateScore(int points) {
        score += points;
    }

    int getScore() const {
        return score;
    }

    std::string getName() const {
        return name;
    }

private:
    std::string name;
    Choice choice;
    int score;
};

class PrisonersDilemma {
public:
    PrisonersDilemma(Player& player1, Player& player2) : player1(player1), player2(player2) {}

    void playRound() {
        int points1 = 0, points2 = 0;

        if (player1.getChoice() == COOPERATE && player2.getChoice() == COOPERATE) {
            points1 = points2 = 3;  // Both cooperate
        } else if (player1.getChoice() == COOPERATE && player2.getChoice() == DEFECT) {
            points1 = 0;  // Player 1 cooperates, Player 2 defects
            points2 = 5;
        } else if (player1.getChoice() == DEFECT && player2.getChoice() == COOPERATE) {
            points1 = 5;  // Player 1 defects, Player 2 cooperates
            points2 = 0;
        } else {
            points1 = points2 = 1;  // Both defect
        }

        player1.updateScore(points1);
        player2.updateScore(points2);

        printRoundResults(points1, points2);
    }

    void printScores() const {
        std::cout << player1.getName() << " Score: " << player1.getScore() << '\n';
        std::cout << player2.getName() << " Score: " << player2.getScore() << '\n';
    }

private:
    Player& player1;
    Player& player2;

    void printRoundResults(int points1, int points2) const {
        std::cout << player1.getName() << " chose " << (player1.getChoice() == COOPERATE ? "Cooperate" : "Defect") << " and scored " << points1 << '\n';
        std::cout << player2.getName() << " chose " << (player2.getChoice() == COOPERATE ? "Cooperate" : "Defect") << " and scored " << points2 << '\n';
    }
};

int main() {
    std::srand(static_cast<unsigned>(std::time(0)));

    Player player1("Player 1");
    Player player2("Player 2");

    // Random strategy for demonstration
    player1.makeChoice(static_cast<Choice>(std::rand() % 2));
    player2.makeChoice(static_cast<Choice>(std::rand() % 2));

    PrisonersDilemma game(player1, player2);

    game.playRound();
    game.printScores();

    return 0;
}

#include <iostream>

#include <vector>

#include <cstdlib>

#include <ctime>

enum Choice { COOPERATE, DEFECT };

class Player {

public:

Player(std::string name) : name(name), score(0) {}

void makeChoice(Choice choice) {

this->choice = choice;

}

Choice getChoice() const {

return choice;

}

void updateScore(int points) {

score += points;

}

int getScore() const {

return score;

}

std::string getName() const {

return name;

}

private:

std::string name;

Choice choice;

int score;

};

class PrisonersDilemma {

public:

PrisonersDilemma(Player& player1, Player& player2) : player1(player1), player2(player2) {}

void playRound() {

int points1 = 0, points2 = 0;

if (player1.getChoice() == COOPERATE && player2.getChoice() == COOPERATE) {

points1 = points2 = 3; // Both cooperate

} else if (player1.getChoice() == COOPERATE && player2.getChoice() == DEFECT) {

points1 = 0; // Player 1 cooperates, Player 2 defects

points2 = 5;

} else if (player1.getChoice() == DEFECT && player2.getChoice() == COOPERATE) {

points1 = 5; // Player 1 defects, Player 2 cooperates

points2 = 0;

} else {

points1 = points2 = 1; // Both defect

}

player1.updateScore(points1);

player2.updateScore(points2);

printRoundResults(points1, points2);

}

void printScores() const {

std::cout << player1.getName() << " Score: " << player1.getScore() << '\n';

std::cout << player2.getName() << " Score: " << player2.getScore() << '\n';

}

private:

Player& player1;

Player& player2;

void printRoundResults(int points1, int points2) const {

std::cout << player1.getName() << " chose " << (player1.getChoice() == COOPERATE ? "Cooperate" : "Defect") << " and scored " << points1 << '\n';

std::cout << player2.getName() << " chose " << (player2.getChoice() == COOPERATE ? "Cooperate" : "Defect") << " and scored " << points2 << '\n';

}

};

int main() {

std::srand(static_cast<unsigned>(std::time(0)));

Player player1("Player 1");

Player player2("Player 2");

// Random strategy for demonstration

player1.makeChoice(static_cast<Choice>(std::rand() % 2));

player2.makeChoice(static_cast<Choice>(std::rand() % 2));

PrisonersDilemma game(player1, player2);

game.playRound();

game.printScores();

return 0;

}

Explanation Class Definitions: Player Class: Private Members: name: The name of the player. choice: The choice made by the player (COOPERATE or DEFECT). score: The score accumulated by the player. Public Methods: Player(std::string name): Constructor initializes the player with a name. void makeChoice(Choice choice): Sets the player’s choice. Choice getChoice() const: Retrieves the player’s …

Simulation of Game Theory Strategies Gaming Project in C++ Read More »

Simulation of Fluid Dynamics Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <vector>
#include <iomanip>

const int GRID_SIZE = 10;
const double DIFFUSION_RATE = 0.1;

class FluidDynamics {
public:
    FluidDynamics() {
        grid.assign(GRID_SIZE, std::vector<double>(GRID_SIZE, 0.0));
        newGrid.assign(GRID_SIZE, std::vector<double>(GRID_SIZE, 0.0));
    }

    void setInitialCondition(int x, int y, double value) {
        if (x >= 0 && x < GRID_SIZE && y >= 0 && y < GRID_SIZE) {
            grid[x][y] = value;
        }
    }

    void simulateStep() {
        for (int i = 0; i < GRID_SIZE; ++i) {
            for (int j = 0; j < GRID_SIZE; ++j) {
                double total = grid[i][j];
                int count = 1;

                if (i > 0) {
                    total += grid[i - 1][j];
                    ++count;
                }
                if (i < GRID_SIZE - 1) {
                    total += grid[i + 1][j];
                    ++count;
                }
                if (j > 0) {
                    total += grid[i][j - 1];
                    ++count;
                }
                if (j < GRID_SIZE - 1) {
                    total += grid[i][j + 1];
                    ++count;
                }

                newGrid[i][j] = (total / count) * (1 - DIFFUSION_RATE) + grid[i][j] * DIFFUSION_RATE;
            }
        }
        grid = newGrid;
    }

    void printGrid() const {
        for (const auto& row : grid) {
            for (double value : row) {
                std::cout << std::setw(6) << std::fixed << std::setprecision(2) << value << ' ';
            }
            std::cout << '\n';
        }
    }

private:
    std::vector<std::vector<double>> grid;
    std::vector<std::vector<double>> newGrid;
};

int main() {
    FluidDynamics fluid;

    // Set initial conditions
    fluid.setInitialCondition(5, 5, 100.0);

    int steps;
    std::cout << "Enter number of simulation steps: ";
    std::cin >> steps;

    for (int i = 0; i < steps; ++i) {
        fluid.simulateStep();
        std::cout << "Step " << i + 1 << ":\n";
        fluid.printGrid();
        std::cout << '\n';
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <iomanip>

const int GRID_SIZE = 10;

const double DIFFUSION_RATE = 0.1;

class FluidDynamics {

public:

FluidDynamics() {

grid.assign(GRID_SIZE, std::vector<double>(GRID_SIZE, 0.0));

newGrid.assign(GRID_SIZE, std::vector<double>(GRID_SIZE, 0.0));

}

void setInitialCondition(int x, int y, double value) {

if (x >= 0 && x < GRID_SIZE && y >= 0 && y < GRID_SIZE) {

grid[x][y] = value;

}

void simulateStep() {

for (int i = 0; i < GRID_SIZE; ++i) {

for (int j = 0; j < GRID_SIZE; ++j) {

double total = grid[i][j];

int count = 1;

if (i > 0) {

total += grid[i - 1][j];

++count;

}

if (i < GRID_SIZE - 1) {

total += grid[i + 1][j];

++count;

}

if (j > 0) {

total += grid[i][j - 1];

++count;

}

if (j < GRID_SIZE - 1) {

total += grid[i][j + 1];

++count;

}

newGrid[i][j] = (total / count) * (1 - DIFFUSION_RATE) + grid[i][j] * DIFFUSION_RATE;

}

grid = newGrid;

}

void printGrid() const {

for (const auto& row : grid) {

for (double value : row) {

std::cout << std::setw(6) << std::fixed << std::setprecision(2) << value << ' ';

}

std::cout << '\n';

}

private:

std::vector<std::vector<double>> grid;

std::vector<std::vector<double>> newGrid;

};

int main() {

FluidDynamics fluid;

// Set initial conditions

fluid.setInitialCondition(5, 5, 100.0);

int steps;

std::cout << "Enter number of simulation steps: ";

std::cin >> steps;

for (int i = 0; i < steps; ++i) {

fluid.simulateStep();

std::cout << "Step " << i + 1 << ":\n";

fluid.printGrid();

std::cout << '\n';

}

return 0;

}

Explanation Class Definition (FluidDynamics): Private Members: grid: 2D vector representing the current state of the fluid on the grid. newGrid: 2D vector for storing the next state of the fluid after each simulation step. Public Methods: FluidDynamics(): Constructor initializes the grid and newGrid with zeros. void setInitialCondition(int x, int y, double value): Sets the …

Simulation of Fluid Dynamics Gaming Project in C++ Read More »

Simulation of Firework Animation Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <vector>
#include <cmath>
#include <thread>
#include <chrono>

class Firework {
public:
    Firework(int x, int y) : x(x), y(y), exploded(false) {}

    void launch() {
        for (int i = 0; i < 10; ++i) {
            if (exploded) break;
            // Simulate the ascent of the firework
            printFrame(x, y - i);
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }
        explode();
    }

private:
    int x, y;
    bool exploded;

    void explode() {
        exploded = true;
        for (int i = 0; i < 20; ++i) {
            // Simulate the explosion effect
            printExplosionFrame(x, y, i);
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
        }
    }

    void printFrame(int x, int y) const {
        system("clear"); // For Linux or Mac
        // system("cls"); // Uncomment this line for Windows
        for (int i = 0; i < y; ++i) {
            std::cout << "\n";
        }
        for (int j = 0; j < x; ++j) {
            std::cout << " ";
        }
        std::cout << "*\n"; // Firework representation
    }

    void printExplosionFrame(int x, int y, int radius) const {
        system("clear"); // For Linux or Mac
        // system("cls"); // Uncomment this line for Windows
        for (int i = 0; i < y; ++i) {
            std::cout << "\n";
        }
        for (int j = 0; j < x; ++j) {
            std::cout << " ";
        }
        for (int i = 0; i < radius; ++i) {
            std::cout << "*";
        }
        std::cout << "\n";
    }
};

int main() {
    int x, y;
    std::cout << "Enter the launch position (x y): ";
    std::cin >> x >> y;

    Firework firework(x, y);
    firework.launch();

    return 0;
}

#include <iostream>

#include <vector>

#include <cmath>

#include <thread>

#include <chrono>

class Firework {

public:

Firework(int x, int y) : x(x), y(y), exploded(false) {}

void launch() {

for (int i = 0; i < 10; ++i) {

if (exploded) break;

// Simulate the ascent of the firework

printFrame(x, y - i);

std::this_thread::sleep_for(std::chrono::milliseconds(100));

}

explode();

}

private:

int x, y;

bool exploded;

void explode() {

exploded = true;

for (int i = 0; i < 20; ++i) {

// Simulate the explosion effect

printExplosionFrame(x, y, i);

std::this_thread::sleep_for(std::chrono::milliseconds(50));

}

void printFrame(int x, int y) const {

system("clear"); // For Linux or Mac

// system("cls"); // Uncomment this line for Windows

for (int i = 0; i < y; ++i) {

std::cout << "\n";

}

for (int j = 0; j < x; ++j) {

std::cout << " ";

}

std::cout << "*\n"; // Firework representation

}

void printExplosionFrame(int x, int y, int radius) const {

system("clear"); // For Linux or Mac

// system("cls"); // Uncomment this line for Windows

for (int i = 0; i < y; ++i) {

std::cout << "\n";

}

for (int j = 0; j < x; ++j) {

std::cout << " ";

}

for (int i = 0; i < radius; ++i) {

std::cout << "*";

}

std::cout << "\n";

}

};

int main() {

int x, y;

std::cout << "Enter the launch position (x y): ";

std::cin >> x >> y;

Firework firework(x, y);

firework.launch();

return 0;

}

Explanation Class Definition (Firework): Private Members: x and y: Coordinates for the firework’s launch position. exploded: A boolean flag indicating whether the firework has exploded. Public Methods: Firework(int x, int y): Constructor to initialize the launch position. void launch(): Simulates the ascent of the firework and triggers the explosion. Calls printFrame to show the …

Simulation of Firework Animation Gaming Project in C++ Read More »

Simulation of Mars Rover Movement Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <string>

class MarsRover {
public:
    MarsRover(int x = 0, int y = 0, char direction = 'N') : x(x), y(y), direction(direction) {}

    void move(const std::string& commands) {
        for (char command : commands) {
            switch (command) {
                case 'L':
                    turnLeft();
                    break;
                case 'R':
                    turnRight();
                    break;
                case 'M':
                    moveForward();
                    break;
                default:
                    std::cerr << "Invalid command: " << command << "\n";
                    break;
            }
        }
    }

    void printPosition() const {
        std::cout << "Rover Position: (" << x << ", " << y << "), Facing: " << direction << "\n";
    }

private:
    int x, y;
    char direction;

    void turnLeft() {
        switch (direction) {
            case 'N': direction = 'W'; break;
            case 'W': direction = 'S'; break;
            case 'S': direction = 'E'; break;
            case 'E': direction = 'N'; break;
        }
    }

    void turnRight() {
        switch (direction) {
            case 'N': direction = 'E'; break;
            case 'E': direction = 'S'; break;
            case 'S': direction = 'W'; break;
            case 'W': direction = 'N'; break;
        }
    }

    void moveForward() {
        switch (direction) {
            case 'N': ++y; break;
            case 'E': ++x; break;
            case 'S': --y; break;
            case 'W': --x; break;
        }
    }
};

int main() {
    MarsRover rover;

    std::string commands;
    std::cout << "Enter commands for the rover (L = turn left, R = turn right, M = move forward): ";
    std::cin >> commands;

    rover.move(commands);
    rover.printPosition();

    return 0;
}

#include <iostream>

#include <string>

class MarsRover {

public:

MarsRover(int x = 0, int y = 0, char direction = 'N') : x(x), y(y), direction(direction) {}

void move(const std::string& commands) {

for (char command : commands) {

switch (command) {

case 'L':

turnLeft();

break;

case 'R':

turnRight();

break;

case 'M':

moveForward();

break;

default:

std::cerr << "Invalid command: " << command << "\n";

break;

}

void printPosition() const {

std::cout << "Rover Position: (" << x << ", " << y << "), Facing: " << direction << "\n";

}

private:

int x, y;

char direction;

void turnLeft() {

switch (direction) {

case 'N': direction = 'W'; break;

case 'W': direction = 'S'; break;

case 'S': direction = 'E'; break;

case 'E': direction = 'N'; break;

}

void turnRight() {

switch (direction) {

case 'N': direction = 'E'; break;

case 'E': direction = 'S'; break;

case 'S': direction = 'W'; break;

case 'W': direction = 'N'; break;

}

void moveForward() {

switch (direction) {

case 'N': ++y; break;

case 'E': ++x; break;

case 'S': --y; break;

case 'W': --x; break;

}

};

int main() {

MarsRover rover;

std::string commands;

std::cout << "Enter commands for the rover (L = turn left, R = turn right, M = move forward): ";

std::cin >> commands;

rover.move(commands);

rover.printPosition();

return 0;

}

Explanation Class Definition (MarsRover): Private Members: x and y: Coordinates of the rover on a 2D grid. direction: The direction the rover is facing (N for North, E for East, S for South, W for West). Public Methods: MarsRover(int x, int y, char direction): Constructor to initialize the rover’s position and direction. void move(const …

Simulation of Mars Rover Movement Gaming Project in C++ Read More »

Simulation of File Compression Algorithms Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <string>
#include <sstream>

// Class for Run-Length Encoding (RLE) compression
class RunLengthEncoder {
public:
    // Function to compress the input string using RLE
    std::string compress(const std::string& input) {
        if (input.empty()) return "";

        std::ostringstream compressed;
        char currentChar = input[0];
        int count = 1;

        for (size_t i = 1; i < input.size(); ++i) {
            if (input[i] == currentChar) {
                ++count;
            } else {
                compressed << currentChar << count;
                currentChar = input[i];
                count = 1;
            }
        }
        compressed << currentChar << count; // Add the last run

        return compressed.str();
    }

    // Function to decompress the RLE compressed string
    std::string decompress(const std::string& compressed) {
        std::ostringstream decompressed;
        size_t i = 0;

        while (i < compressed.size()) {
            char currentChar = compressed[i++];
            int count = 0;
            while (i < compressed.size() && std::isdigit(compressed[i])) {
                count = count * 10 + (compressed[i++] - '0');
            }
            decompressed << std::string(count, currentChar);
        }

        return decompressed.str();
    }
};

int main() {
    RunLengthEncoder rle;
    std::string input;

    std::cout << "Enter the string to compress: ";
    std::getline(std::cin, input);

    // Compress the input string
    std::string compressed = rle.compress(input);
    std::cout << "Compressed string: " << compressed << std::endl;

    // Decompress the string
    std::string decompressed = rle.decompress(compressed);
    std::cout << "Decompressed string: " << decompressed << std::endl;

    return 0;
}

#include <iostream>

#include <string>

#include <sstream>

// Class for Run-Length Encoding (RLE) compression

class RunLengthEncoder {

public:

// Function to compress the input string using RLE

std::string compress(const std::string& input) {

if (input.empty()) return "";

std::ostringstream compressed;

char currentChar = input[0];

int count = 1;

for (size_t i = 1; i < input.size(); ++i) {

if (input[i] == currentChar) {

++count;

} else {

compressed << currentChar << count;

currentChar = input[i];

count = 1;

}

compressed << currentChar << count; // Add the last run

return compressed.str();

}

// Function to decompress the RLE compressed string

std::string decompress(const std::string& compressed) {

std::ostringstream decompressed;

size_t i = 0;

while (i < compressed.size()) {

char currentChar = compressed[i++];

int count = 0;

while (i < compressed.size() && std::isdigit(compressed[i])) {

count = count * 10 + (compressed[i++] - '0');

}

decompressed << std::string(count, currentChar);

}

return decompressed.str();

}

};

int main() {

RunLengthEncoder rle;

std::string input;

std::cout << "Enter the string to compress: ";

std::getline(std::cin, input);

// Compress the input string

std::string compressed = rle.compress(input);

std::cout << "Compressed string: " << compressed << std::endl;

// Decompress the string

std::string decompressed = rle.decompress(compressed);

std::cout << "Decompressed string: " << decompressed << std::endl;

return 0;

}

Explanation Class Definition (RunLengthEncoder): Public Methods: compress(const std::string& input): Compresses the input string using Run-Length Encoding (RLE). Iterates through the string, counting consecutive occurrences of each character. Constructs a compressed string in the format: character followed by the count. Returns the compressed string. decompress(const std::string& compressed): Decompresses a string that was compressed using RLE. …

Simulation of File Compression Algorithms Gaming Project in C++ Read More »

Simulation of Financial Management Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <vector>
#include <iomanip>

class Transaction {
public:
    enum class Type { DEPOSIT, WITHDRAWAL };

    Transaction(Type type, double amount) : type(type), amount(amount) {}

    Type getType() const { return type; }
    double getAmount() const { return amount; }

private:
    Type type;
    double amount;
};

class FinancialManager {
public:
    FinancialManager(double initialBalance) : balance(initialBalance) {}

    void deposit(double amount) {
        balance += amount;
        transactions.emplace_back(Transaction::Type::DEPOSIT, amount);
    }

    bool withdraw(double amount) {
        if (amount > balance) {
            std::cerr << "Insufficient funds.\n";
            return false;
        }
        balance -= amount;
        transactions.emplace_back(Transaction::Type::WITHDRAWAL, amount);
        return true;
    }

    void printStatement() const {
        std::cout << "Balance: $" << std::fixed << std::setprecision(2) << balance << "\n";
        std::cout << "Transactions:\n";
        for (const auto& transaction : transactions) {
            std::cout << (transaction.getType() == Transaction::Type::DEPOSIT ? "Deposit" : "Withdrawal")
                      << ": $" << std::fixed << std::setprecision(2) << transaction.getAmount() << "\n";
        }
    }

private:
    double balance;
    std::vector<Transaction> transactions;
};

int main() {
    double initialBalance;
    std::cout << "Enter initial balance: $";
    std::cin >> initialBalance;

    FinancialManager manager(initialBalance);

    while (true) {
        int choice;
        std::cout << "\n1. Deposit\n2. Withdraw\n3. Print Statement\n4. Exit\n";
        std::cout << "Enter your choice: ";
        std::cin >> choice;

        if (choice == 1) {
            double amount;
            std::cout << "Enter amount to deposit: $";
            std::cin >> amount;
            manager.deposit(amount);
        } else if (choice == 2) {
            double amount;
            std::cout << "Enter amount to withdraw: $";
            std::cin >> amount;
            manager.withdraw(amount);
        } else if (choice == 3) {
            manager.printStatement();
        } else if (choice == 4) {
            break;
        } else {
            std::cout << "Invalid choice. Please try again.\n";
        }
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <iomanip>

class Transaction {

public:

enum class Type { DEPOSIT, WITHDRAWAL };

Transaction(Type type, double amount) : type(type), amount(amount) {}

Type getType() const { return type; }

double getAmount() const { return amount; }

private:

Type type;

double amount;

};

class FinancialManager {

public:

FinancialManager(double initialBalance) : balance(initialBalance) {}

void deposit(double amount) {

balance += amount;

transactions.emplace_back(Transaction::Type::DEPOSIT, amount);

}

bool withdraw(double amount) {

if (amount > balance) {

std::cerr << "Insufficient funds.\n";

return false;

}

balance -= amount;

transactions.emplace_back(Transaction::Type::WITHDRAWAL, amount);

return true;

}

void printStatement() const {

std::cout << "Balance: $" << std::fixed << std::setprecision(2) << balance << "\n";

std::cout << "Transactions:\n";

for (const auto& transaction : transactions) {

std::cout << (transaction.getType() == Transaction::Type::DEPOSIT ? "Deposit" : "Withdrawal")

<< ": $" << std::fixed << std::setprecision(2) << transaction.getAmount() << "\n";

}

private:

double balance;

std::vector<Transaction> transactions;

};

int main() {

double initialBalance;

std::cout << "Enter initial balance: $";

std::cin >> initialBalance;

FinancialManager manager(initialBalance);

while (true) {

int choice;

std::cout << "\n1. Deposit\n2. Withdraw\n3. Print Statement\n4. Exit\n";

std::cout << "Enter your choice: ";

std::cin >> choice;

if (choice == 1) {

double amount;

std::cout << "Enter amount to deposit: $";

std::cin >> amount;

manager.deposit(amount);

} else if (choice == 2) {

double amount;

std::cout << "Enter amount to withdraw: $";

std::cin >> amount;

manager.withdraw(amount);

} else if (choice == 3) {

manager.printStatement();

} else if (choice == 4) {

break;

} else {

std::cout << "Invalid choice. Please try again.\n";

}

return 0;

}

Explanation Class Definition: Transaction Class: Represents a financial transaction with type (DEPOSIT or WITHDRAWAL) and amount. Constructor: Initializes the type and amount of the transaction. Getters: Retrieve the type and amount of the transaction. FinancialManager Class: Manages account balance and records transactions. Private Members: balance: Current balance of the account. transactions: Vector storing all …

Simulation of Financial Management Gaming Project in C++ Read More »

Simulation of Memory Allocation Algorithms Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <vector>
#include <algorithm>

class MemoryAllocator {
public:
    // Constructor
    MemoryAllocator(int totalSize) : totalSize(totalSize) {
        memory.resize(totalSize, false); // Initialize memory as free (false)
    }

    // Function to allocate memory using First Fit algorithm
    bool allocateFirstFit(int size) {
        int start = -1;
        int freeSize = 0;
        
        for (int i = 0; i < totalSize; ++i) {
            if (!memory[i]) { // Free block
                if (start == -1) start = i;
                ++freeSize;
                if (freeSize == size) {
                    std::fill(memory.begin() + start, memory.begin() + start + size, true);
                    return true;
                }
            } else {
                start = -1;
                freeSize = 0;
            }
        }
        return false;
    }

    // Function to deallocate memory
    void deallocate(int start, int size) {
        std::fill(memory.begin() + start, memory.begin() + start + size, false);
    }

    // Function to print the current state of memory
    void printMemory() const {
        std::cout << "Memory: ";
        for (bool block : memory) {
            std::cout << (block ? '1' : '0') << ' ';
        }
        std::cout << '\n';
    }

private:
    int totalSize;
    std::vector<bool> memory; // true if allocated, false if free
};

int main() {
    int totalSize, allocationSize;

    std::cout << "Enter total memory size: ";
    std::cin >> totalSize;

    MemoryAllocator allocator(totalSize);

    while (true) {
        int choice;
        std::cout << "\n1. Allocate memory (First Fit)\n2. Deallocate memory\n3. Print memory\n4. Exit\n";
        std::cout << "Enter your choice: ";
        std::cin >> choice;

        switch (choice) {
            case 1:
                std::cout << "Enter size of memory to allocate: ";
                std::cin >> allocationSize;
                if (allocator.allocateFirstFit(allocationSize)) {
                    std::cout << "Memory allocated successfully.\n";
                } else {
                    std::cout << "Not enough memory available.\n";
                }
                break;

            case 2:
                int start, size;
                std::cout << "Enter starting index and size of memory to deallocate: ";
                std::cin >> start >> size;
                allocator.deallocate(start, size);
                std::cout << "Memory deallocated successfully.\n";
                break;

            case 3:
                allocator.printMemory();
                break;

            case 4:
                return 0;

            default:
                std::cout << "Invalid choice. Please try again.\n";
        }
    }
}

#include <iostream>

#include <vector>

#include <algorithm>

class MemoryAllocator {

public:

// Constructor

MemoryAllocator(int totalSize) : totalSize(totalSize) {

memory.resize(totalSize, false); // Initialize memory as free (false)

}

// Function to allocate memory using First Fit algorithm

bool allocateFirstFit(int size) {

int start = -1;

int freeSize = 0;

for (int i = 0; i < totalSize; ++i) {

if (!memory[i]) { // Free block

if (start == -1) start = i;

++freeSize;

if (freeSize == size) {

std::fill(memory.begin() + start, memory.begin() + start + size, true);

return true;

}

} else {

start = -1;

freeSize = 0;

}

return false;

}

// Function to deallocate memory

void deallocate(int start, int size) {

std::fill(memory.begin() + start, memory.begin() + start + size, false);

}

// Function to print the current state of memory

void printMemory() const {

std::cout << "Memory: ";

for (bool block : memory) {

std::cout << (block ? '1' : '0') << ' ';

}

std::cout << '\n';

}

private:

int totalSize;

std::vector<bool> memory; // true if allocated, false if free

};

int main() {

int totalSize, allocationSize;

std::cout << "Enter total memory size: ";

std::cin >> totalSize;

MemoryAllocator allocator(totalSize);

while (true) {

int choice;

std::cout << "\n1. Allocate memory (First Fit)\n2. Deallocate memory\n3. Print memory\n4. Exit\n";

std::cout << "Enter your choice: ";

std::cin >> choice;

switch (choice) {

case 1:

std::cout << "Enter size of memory to allocate: ";

std::cin >> allocationSize;

if (allocator.allocateFirstFit(allocationSize)) {

std::cout << "Memory allocated successfully.\n";

} else {

std::cout << "Not enough memory available.\n";

}

break;

case 2:

int start, size;

std::cout << "Enter starting index and size of memory to deallocate: ";

std::cin >> start >> size;

allocator.deallocate(start, size);

std::cout << "Memory deallocated successfully.\n";

break;

case 3:

allocator.printMemory();

break;

case 4:

return 0;

default:

std::cout << "Invalid choice. Please try again.\n";

}

Explanation Class Definition (MemoryAllocator): Private Members: totalSize: Total size of the memory. memory: A vector of booleans representing memory blocks; true for allocated and false for free. Public Methods: allocateFirstFit(int size): Allocates a contiguous block of memory of the given size using the First Fit algorithm. Searches for the first block of sufficient size …

Simulation of Memory Allocation Algorithms Gaming Project in C++ Read More »

Simulation of Multiplexing and Demultiplexing Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>

class Multiplexer {
private:
    std::vector<std::queue<int>> inputQueues; // Input queues for multiplexing
    std::queue<int> outputQueue;              // Output queue for multiplexed data

public:
    // Constructor
    Multiplexer(int numInputs) {
        inputQueues.resize(numInputs);
    }

    // Function to add data to an input queue
    void addData(int inputIndex, int data) {
        if (inputIndex < inputQueues.size()) {
            inputQueues[inputIndex].push(data);
        } else {
            std::cerr << "Invalid input index.\n";
        }
    }

    // Function to multiplex data from all input queues into the output queue
    void multiplex() {
        outputQueue = {}; // Clear the output queue
        for (auto& queue : inputQueues) {
            while (!queue.empty()) {
                outputQueue.push(queue.front());
                queue.pop();
            }
        }
    }

    // Function to get data from the output queue
    int getData() {
        if (outputQueue.empty()) {
            throw std::runtime_error("Output queue is empty.");
        }
        int data = outputQueue.front();
        outputQueue.pop();
        return data;
    }

    // Function to check if the output queue is empty
    bool isOutputEmpty() const {
        return outputQueue.empty();
    }
};

class Demultiplexer {
private:
    std::vector<std::queue<int>> outputQueues; // Output queues for demultiplexing

public:
    // Constructor
    Demultiplexer(int numOutputs) {
        outputQueues.resize(numOutputs);
    }

    // Function to demultiplex data into the specified output queue
    void demultiplex(int outputIndex, int data) {
        if (outputIndex < outputQueues.size()) {
            outputQueues[outputIndex].push(data);
        } else {
            std::cerr << "Invalid output index.\n";
        }
    }

    // Function to get data from a specific output queue
    int getData(int outputIndex) {
        if (outputIndex >= outputQueues.size()) {
            throw std::runtime_error("Invalid output index.");
        }
        if (outputQueues[outputIndex].empty()) {
            throw std::runtime_error("Output queue is empty.");
        }
        int data = outputQueues[outputIndex].front();
        outputQueues[outputIndex].pop();
        return data;
    }

    // Function to check if a specific output queue is empty
    bool isOutputEmpty(int outputIndex) const {
        if (outputIndex >= outputQueues.size()) {
            throw std::runtime_error("Invalid output index.");
        }
        return outputQueues[outputIndex].empty();
    }
};

int main() {
    int numInputs = 3;
    int numOutputs = 2;
    Multiplexer mux(numInputs);
    Demultiplexer demux(numOutputs);

    // Add data to input queues
    mux.addData(0, 10);
    mux.addData(1, 20);
    mux.addData(2, 30);
    mux.addData(0, 40);
    mux.addData(1, 50);

    // Perform multiplexing
    mux.multiplex();

    // Perform demultiplexing
    while (!mux.isOutputEmpty()) {
        int data = mux.getData();
        // Simulate demultiplexing based on some criteria
        int outputIndex = (data % numOutputs); // Example criterion for output index
        demux.demultiplex(outputIndex, data);
    }

    // Display data from output queues
    for (int i = 0; i < numOutputs; ++i) {
        std::cout << "Output Queue " << i << ": ";
        while (!demux.isOutputEmpty(i)) {
            std::cout << demux.getData(i) << " ";
        }
        std::cout << "\n";
    }

    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

#include <iostream>

#include <vector>

#include <queue>

#include <algorithm>

class Multiplexer {

private:

std::vector<std::queue<int>> inputQueues; // Input queues for multiplexing

std::queue<int> outputQueue; // Output queue for multiplexed data

public:

// Constructor

Multiplexer(int numInputs) {

inputQueues.resize(numInputs);

}

// Function to add data to an input queue

void addData(int inputIndex, int data) {

if (inputIndex < inputQueues.size()) {

inputQueues[inputIndex].push(data);

} else {

std::cerr << "Invalid input index.\n";

}

// Function to multiplex data from all input queues into the output queue

void multiplex() {

outputQueue = {}; // Clear the output queue

for (auto& queue : inputQueues) {

while (!queue.empty()) {

outputQueue.push(queue.front());

queue.pop();

}

// Function to get data from the output queue

int getData() {

if (outputQueue.empty()) {

throw std::runtime_error("Output queue is empty.");

}

int data = outputQueue.front();

outputQueue.pop();

return data;

}

// Function to check if the output queue is empty

bool isOutputEmpty() const {

return outputQueue.empty();

}

};

class Demultiplexer {

private:

std::vector<std::queue<int>> outputQueues; // Output queues for demultiplexing

public:

// Constructor

Demultiplexer(int numOutputs) {

outputQueues.resize(numOutputs);

}

// Function to demultiplex data into the specified output queue

void demultiplex(int outputIndex, int data) {

if (outputIndex < outputQueues.size()) {

outputQueues[outputIndex].push(data);

} else {

std::cerr << "Invalid output index.\n";

}

// Function to get data from a specific output queue

int getData(int outputIndex) {

if (outputIndex >= outputQueues.size()) {

throw std::runtime_error("Invalid output index.");

}

if (outputQueues[outputIndex].empty()) {

throw std::runtime_error("Output queue is empty.");

}

int data = outputQueues[outputIndex].front();

outputQueues[outputIndex].pop();

return data;

}

// Function to check if a specific output queue is empty

bool isOutputEmpty(int outputIndex) const {

if (outputIndex >= outputQueues.size()) {

throw std::runtime_error("Invalid output index.");

}

return outputQueues[outputIndex].empty();

}

};

int main() {

int numInputs = 3;

int numOutputs = 2;

Multiplexer mux(numInputs);

Demultiplexer demux(numOutputs);

// Add data to input queues

mux.addData(0, 10);

mux.addData(1, 20);

mux.addData(2, 30);

mux.addData(0, 40);

mux.addData(1, 50);

// Perform multiplexing

mux.multiplex();

// Perform demultiplexing

while (!mux.isOutputEmpty()) {

int data = mux.getData();

// Simulate demultiplexing based on some criteria

int outputIndex = (data % numOutputs); // Example criterion for output index

demux.demultiplex(outputIndex, data);

}

// Display data from output queues

for (int i = 0; i < numOutputs; ++i) {

std::cout << "Output Queue " << i << ": ";

while (!demux.isOutputEmpty(i)) {

std::cout << demux.getData(i) << " ";

}

std::cout << "\n";

}

return 0;

}

Explanation Class Definitions: Multiplexer: Simulates the multiplexing of data from multiple input queues into a single output queue. Private Members: inputQueues: A vector of queues where data is added for multiplexing. outputQueue: A single queue where data from all input queues is combined. Public Methods: addData(int inputIndex, int data): Adds data to a specific …

Simulation of Multiplexing and Demultiplexing Gaming Project in C++ Read More »

Simulation of Natural Language Processing Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <string>
#include <map>
#include <sstream>
#include <algorithm>

class SimpleNLP {
private:
    std::map<std::string, int> wordFrequency; // To store word frequency

public:
    // Function to process a text input and count word frequencies
    void processText(const std::string& text) {
        std::string word;
        std::istringstream stream(text);
        
        while (stream >> word) {
            // Remove punctuation from the word
            word.erase(std::remove_if(word.begin(), word.end(), ::ispunct), word.end());
            // Convert to lowercase
            std::transform(word.begin(), word.end(), word.begin(), ::tolower);
            // Update word frequency
            ++wordFrequency[word];
        }
    }

    // Function to display the word frequencies
    void displayWordFrequencies() const {
        std::cout << "Word Frequencies:\n";
        for (const auto& pair : wordFrequency) {
            std::cout << pair.first << ": " << pair.second << "\n";
        }
    }
};

int main() {
    std::string text;

    // Input text from the user
    std::cout << "Enter the text for NLP processing (end input with an empty line):\n";
    std::getline(std::cin, text);
    
    // Create a SimpleNLP object
    SimpleNLP nlp;

    // Process the input text
    nlp.processText(text);

    // Display the word frequencies
    nlp.displayWordFrequencies();

    return 0;
}

#include <iostream>

#include <string>

#include <map>

#include <sstream>

#include <algorithm>

class SimpleNLP {

private:

std::map<std::string, int> wordFrequency; // To store word frequency

public:

// Function to process a text input and count word frequencies

void processText(const std::string& text) {

std::string word;

std::istringstream stream(text);

while (stream >> word) {

// Remove punctuation from the word

word.erase(std::remove_if(word.begin(), word.end(), ::ispunct), word.end());

// Convert to lowercase

std::transform(word.begin(), word.end(), word.begin(), ::tolower);

// Update word frequency

++wordFrequency[word];

}

// Function to display the word frequencies

void displayWordFrequencies() const {

std::cout << "Word Frequencies:\n";

for (const auto& pair : wordFrequency) {

std::cout << pair.first << ": " << pair.second << "\n";

}

};

int main() {

std::string text;

// Input text from the user

std::cout << "Enter the text for NLP processing (end input with an empty line):\n";

std::getline(std::cin, text);

// Create a SimpleNLP object

SimpleNLP nlp;

// Process the input text

nlp.processText(text);

// Display the word frequencies

nlp.displayWordFrequencies();

return 0;

}

Explanation Class Definition (SimpleNLP): Private Members: wordFrequency: A std::map to store the frequency of each word in the text. processText Method: Takes a string of text as input and processes it to count the frequency of each word. Uses std::istringstream to tokenize the input text. Removes punctuation from each word and converts it to …

Simulation of Natural Language Processing Gaming Project in C++ Read More »