C++ Projects – Page 17 – Projects Inventory

Matrix Operations (Addition, Multiplication) Gaming Project in C++

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

#include <iostream>
#include <vector>

using namespace std;

// Function to add two matrices
vector<vector<int>> addMatrices(const vector<vector<int>>& mat1, const vector<vector<int>>& mat2) {
    int rows = mat1.size();
    int cols = mat1[0].size();
    vector<vector<int>> result(rows, vector<int>(cols));

    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            result[i][j] = mat1[i][j] + mat2[i][j];
        }
    }
    return result;
}

// Function to multiply two matrices
vector<vector<int>> multiplyMatrices(const vector<vector<int>>& mat1, const vector<vector<int>>& mat2) {
    int rows1 = mat1.size();
    int cols1 = mat1[0].size();
    int rows2 = mat2.size();
    int cols2 = mat2[0].size();

    if (cols1 != rows2) {
        throw invalid_argument("Matrix dimensions do not match for multiplication.");
    }

    vector<vector<int>> result(rows1, vector<int>(cols2, 0));

    for (int i = 0; i < rows1; ++i) {
        for (int j = 0; j < cols2; ++j) {
            for (int k = 0; k < cols1; ++k) {
                result[i][j] += mat1[i][k] * mat2[k][j];
            }
        }
    }
    return result;
}

// Function to print a matrix
void printMatrix(const vector<vector<int>>& mat) {
    for (const auto& row : mat) {
        for (int val : row) {
            cout << val << " ";
        }
        cout << endl;
    }
}

int main() {
    // Define two matrices
    vector<vector<int>> mat1 = {
        {1, 2},
        {3, 4}
    };

    vector<vector<int>> mat2 = {
        {5, 6},
        {7, 8}
    };

    // Add matrices
    vector<vector<int>> sum = addMatrices(mat1, mat2);
    cout << "Sum of matrices:" << endl;
    printMatrix(sum);

    // Multiply matrices
    try {
        vector<vector<int>> product = multiplyMatrices(mat1, mat2);
        cout << "Product of matrices:" << endl;
        printMatrix(product);
    } catch (const invalid_argument& e) {
        cerr << e.what() << endl;
    }

    return 0;
}

#include <iostream>

#include <vector>

using namespace std;

// Function to add two matrices

vector<vector<int>> addMatrices(const vector<vector<int>>& mat1, const vector<vector<int>>& mat2) {

int rows = mat1.size();

int cols = mat1[0].size();

vector<vector<int>> result(rows, vector<int>(cols));

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

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

result[i][j] = mat1[i][j] + mat2[i][j];

}

return result;

}

// Function to multiply two matrices

vector<vector<int>> multiplyMatrices(const vector<vector<int>>& mat1, const vector<vector<int>>& mat2) {

int rows1 = mat1.size();

int cols1 = mat1[0].size();

int rows2 = mat2.size();

int cols2 = mat2[0].size();

if (cols1 != rows2) {

throw invalid_argument("Matrix dimensions do not match for multiplication.");

}

vector<vector<int>> result(rows1, vector<int>(cols2, 0));

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

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

for (int k = 0; k < cols1; ++k) {

result[i][j] += mat1[i][k] * mat2[k][j];

}

return result;

}

// Function to print a matrix

void printMatrix(const vector<vector<int>>& mat) {

for (const auto& row : mat) {

for (int val : row) {

cout << val << " ";

}

cout << endl;

}

int main() {

// Define two matrices

vector<vector<int>> mat1 = {

{1, 2},

{3, 4}

};

vector<vector<int>> mat2 = {

{5, 6},

{7, 8}

};

// Add matrices

vector<vector<int>> sum = addMatrices(mat1, mat2);

cout << "Sum of matrices:" << endl;

printMatrix(sum);

// Multiply matrices

try {

vector<vector<int>> product = multiplyMatrices(mat1, mat2);

cout << "Product of matrices:" << endl;

printMatrix(product);

} catch (const invalid_argument& e) {

cerr << e.what() << endl;

}

return 0;

}

Explanation Matrix Addition (addMatrices): Takes two matrices mat1 and mat2 as input. Assumes that both matrices have the same dimensions. Creates a result matrix with the same dimensions. Adds corresponding elements from both matrices to fill the result matrix. Matrix Multiplication (multiplyMatrices): Takes two matrices mat1 and mat2 as input. Checks if the number …

Matrix Operations (Addition, Multiplication) Gaming Project in C++ Read More »

Linked List Implementation Gaming Project in C++

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

#include <iostream>

using namespace std;

// Node structure for the linked list
struct Node {
    int data;
    Node* next;

    Node(int value) : data(value), next(nullptr) {}
};

// Linked list class
class LinkedList {
private:
    Node* head;

public:
    LinkedList() : head(nullptr) {}

    ~LinkedList() {
        Node* current = head;
        while (current != nullptr) {
            Node* nextNode = current->next;
            delete current;
            current = nextNode;
        }
    }

    // Add a node to the end of the list
    void append(int value) {
        Node* newNode = new Node(value);
        if (head == nullptr) {
            head = newNode;
        } else {
            Node* current = head;
            while (current->next != nullptr) {
                current = current->next;
            }
            current->next = newNode;
        }
    }

    // Print all nodes in the list
    void printList() const {
        Node* current = head;
        while (current != nullptr) {
            cout << current->data << " -> ";
            current = current->next;
        }
        cout << "nullptr" << endl;
    }

    // Delete a node with a specific value
    void deleteValue(int value) {
        Node* current = head;
        Node* prev = nullptr;

        // Check if the node to be deleted is the head
        if (current != nullptr && current->data == value) {
            head = current->next;
            delete current;
            return;
        }

        // Search for the node to be deleted
        while (current != nullptr && current->data != value) {
            prev = current;
            current = current->next;
        }

        // If the value was not found
        if (current == nullptr) {
            cout << "Value not found in the list." << endl;
            return;
        }

        // Unlink the node from the linked list
        prev->next = current->next;
        delete current;
    }
};

int main() {
    LinkedList list;

    // Append values to the list
    list.append(10);
    list.append(20);
    list.append(30);
    list.append(40);

    // Print the list
    cout << "Linked List: ";
    list.printList();

    // Delete a node and print the list again
    list.deleteValue(20);
    cout << "After deleting 20: ";
    list.printList();

    return 0;
}

100

101

102

103

#include <iostream>

using namespace std;

// Node structure for the linked list

struct Node {

int data;

Node* next;

Node(int value) : data(value), next(nullptr) {}

};

// Linked list class

class LinkedList {

private:

Node* head;

public:

LinkedList() : head(nullptr) {}

~LinkedList() {

Node* current = head;

while (current != nullptr) {

Node* nextNode = current->next;

delete current;

current = nextNode;

}

// Add a node to the end of the list

void append(int value) {

Node* newNode = new Node(value);

if (head == nullptr) {

head = newNode;

} else {

Node* current = head;

while (current->next != nullptr) {

current = current->next;

}

current->next = newNode;

}

// Print all nodes in the list

void printList() const {

Node* current = head;

while (current != nullptr) {

cout << current->data << " -> ";

current = current->next;

}

cout << "nullptr" << endl;

}

// Delete a node with a specific value

void deleteValue(int value) {

Node* current = head;

Node* prev = nullptr;

// Check if the node to be deleted is the head

if (current != nullptr && current->data == value) {

head = current->next;

delete current;

return;

}

// Search for the node to be deleted

while (current != nullptr && current->data != value) {

prev = current;

current = current->next;

}

// If the value was not found

if (current == nullptr) {

cout << "Value not found in the list." << endl;

return;

}

// Unlink the node from the linked list

prev->next = current->next;

delete current;

}

};

int main() {

LinkedList list;

// Append values to the list

list.append(10);

list.append(20);

list.append(30);

list.append(40);

// Print the list

cout << "Linked List: ";

list.printList();

// Delete a node and print the list again

list.deleteValue(20);

cout << "After deleting 20: ";

list.printList();

return 0;

}

Explanation Node Structure: Defines the building block of the linked list. data: Holds the value of the node. next: Points to the next node in the list. LinkedList Class: Manages the linked list operations. Constructor: Initializes head to nullptr, indicating an empty list. Destructor: Deletes all nodes to free up memory when the list …

Linked List Implementation Gaming Project in C++ Read More »

Library Management System Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <string>

using namespace std;

class Book {
public:
    string title;
    string author;
    bool isAvailable;

    Book(const string& t, const string& a) : title(t), author(a), isAvailable(true) {}
};

class Library {
private:
    vector<Book> books;

public:
    void addBook(const string& title, const string& author) {
        books.emplace_back(title, author);
        cout << "Book added: " << title << " by " << author << endl;
    }

    void borrowBook(const string& title) {
        for (auto& book : books) {
            if (book.title == title) {
                if (book.isAvailable) {
                    book.isAvailable = false;
                    cout << "You have borrowed: " << title << endl;
                    return;
                } else {
                    cout << "Sorry, the book is not available right now." << endl;
                    return;
                }
            }
        }
        cout << "Book not found." << endl;
    }

    void returnBook(const string& title) {
        for (auto& book : books) {
            if (book.title == title) {
                if (!book.isAvailable) {
                    book.isAvailable = true;
                    cout << "You have returned: " << title << endl;
                    return;
                } else {
                    cout << "This book was not borrowed." << endl;
                    return;
                }
            }
        }
        cout << "Book not found." << endl;
    }

    void listBooks() const {
        cout << "Library Books:" << endl;
        for (const auto& book : books) {
            cout << "Title: " << book.title << ", Author: " << book.author
                 << ", " << (book.isAvailable ? "Available" : "Not Available") << endl;
        }
    }
};

int main() {
    Library library;

    library.addBook("1984", "George Orwell");
    library.addBook("To Kill a Mockingbird", "Harper Lee");

    library.listBooks();

    library.borrowBook("1984");
    library.listBooks();

    library.returnBook("1984");
    library.listBooks();

    return 0;
}

#include <iostream>

#include <vector>

#include <string>

using namespace std;

class Book {

public:

string title;

string author;

bool isAvailable;

Book(const string& t, const string& a) : title(t), author(a), isAvailable(true) {}

};

class Library {

private:

vector<Book> books;

public:

void addBook(const string& title, const string& author) {

books.emplace_back(title, author);

cout << "Book added: " << title << " by " << author << endl;

}

void borrowBook(const string& title) {

for (auto& book : books) {

if (book.title == title) {

if (book.isAvailable) {

book.isAvailable = false;

cout << "You have borrowed: " << title << endl;

return;

} else {

cout << "Sorry, the book is not available right now." << endl;

return;

}

cout << "Book not found." << endl;

}

void returnBook(const string& title) {

for (auto& book : books) {

if (book.title == title) {

if (!book.isAvailable) {

book.isAvailable = true;

cout << "You have returned: " << title << endl;

return;

} else {

cout << "This book was not borrowed." << endl;

return;

}

cout << "Book not found." << endl;

}

void listBooks() const {

cout << "Library Books:" << endl;

for (const auto& book : books) {

cout << "Title: " << book.title << ", Author: " << book.author

<< ", " << (book.isAvailable ? "Available" : "Not Available") << endl;

}

};

int main() {

Library library;

library.addBook("1984", "George Orwell");

library.addBook("To Kill a Mockingbird", "Harper Lee");

library.listBooks();

library.borrowBook("1984");

library.listBooks();

library.returnBook("1984");

library.listBooks();

return 0;

}

Explanation Book Class: Represents a book with attributes for the title, author, and availability status. title: The title of the book. author: The author of the book. isAvailable: A boolean indicating if the book is available for borrowing. Library Class: Manages a collection of books and provides functionality for adding, borrowing, returning, and listing …

Library Management System Gaming Project in C++ Read More »

Image Steganography Gaming Project in C++

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

#include <iostream>
#include <opencv2/opencv.hpp>

using namespace cv;
using namespace std;

// Function to hide a message in an image
void encodeMessage(Mat& image, const string& message) {
    // Ensure message fits in the image
    int msgLength = message.size();
    if (msgLength > image.rows * image.cols / 8) {
        cerr << "Error: Message is too long to encode in the image!" << endl;
        return;
    }

    // Convert message to binary
    string binaryMessage;
    for (char c : message) {
        for (int i = 7; i >= 0; --i) {
            binaryMessage += (c & (1 << i)) ? '1' : '0';
        }
    }
    binaryMessage += '0'; // Add a terminator for the message

    // Encode binary message into the image's LSB
    int bitIndex = 0;
    for (int y = 0; y < image.rows; ++y) {
        for (int x = 0; x < image.cols; ++x) {
            Vec3b& pixel = image.at<Vec3b>(y, x);
            for (int c = 0; c < 3; ++c) {
                if (bitIndex < binaryMessage.size()) {
                    pixel[c] = (pixel[c] & ~1) | (binaryMessage[bitIndex] - '0');
                    ++bitIndex;
                }
            }
        }
    }
}

// Function to extract a message from an image
string decodeMessage(const Mat& image) {
    string binaryMessage;
    for (int y = 0; y < image.rows; ++y) {
        for (int x = 0; x < image.cols; ++x) {
            Vec3b pixel = image.at<Vec3b>(y, x);
            for (int c = 0; c < 3; ++c) {
                binaryMessage += (pixel[c] & 1) ? '1' : '0';
                if (binaryMessage.size() >= 8 && binaryMessage.substr(binaryMessage.size() - 8) == "00000000") {
                    return binaryMessage.substr(0, binaryMessage.size() - 8);
                }
            }
        }
    }
    return "";
}

int main() {
    // Load an image from file
    Mat image = imread("path/to/your/image.png");

    if (image.empty()) {
        cerr << "Error: Could not load image!" << endl;
        return -1;
    }

    // Encode a message into the image
    string message = "Hello, Steganography!";
    encodeMessage(image, message);
    
    // Save the modified image
    imwrite("encoded_image.png", image);

    // Load the modified image
    Mat encodedImage = imread("encoded_image.png");

    // Decode the message from the image
    string decodedMessage = decodeMessage(encodedImage);
    cout << "Decoded Message: " << decodedMessage << endl;

    return 0;
}

#include <iostream>

#include <opencv2/opencv.hpp>

using namespace cv;

using namespace std;

// Function to hide a message in an image

void encodeMessage(Mat& image, const string& message) {

// Ensure message fits in the image

int msgLength = message.size();

if (msgLength > image.rows * image.cols / 8) {

cerr << "Error: Message is too long to encode in the image!" << endl;

return;

}

// Convert message to binary

string binaryMessage;

for (char c : message) {

for (int i = 7; i >= 0; --i) {

binaryMessage += (c & (1 << i)) ? '1' : '0';

}

binaryMessage += '0'; // Add a terminator for the message

// Encode binary message into the image's LSB

int bitIndex = 0;

for (int y = 0; y < image.rows; ++y) {

for (int x = 0; x < image.cols; ++x) {

Vec3b& pixel = image.at<Vec3b>(y, x);

for (int c = 0; c < 3; ++c) {

if (bitIndex < binaryMessage.size()) {

pixel[c] = (pixel[c] & ~1) | (binaryMessage[bitIndex] - '0');

++bitIndex;

}

// Function to extract a message from an image

string decodeMessage(const Mat& image) {

string binaryMessage;

for (int y = 0; y < image.rows; ++y) {

for (int x = 0; x < image.cols; ++x) {

Vec3b pixel = image.at<Vec3b>(y, x);

for (int c = 0; c < 3; ++c) {

binaryMessage += (pixel[c] & 1) ? '1' : '0';

if (binaryMessage.size() >= 8 && binaryMessage.substr(binaryMessage.size() - 8) == "00000000") {

return binaryMessage.substr(0, binaryMessage.size() - 8);

}

return "";

}

int main() {

// Load an image from file

Mat image = imread("path/to/your/image.png");

if (image.empty()) {

cerr << "Error: Could not load image!" << endl;

return -1;

}

// Encode a message into the image

string message = "Hello, Steganography!";

encodeMessage(image, message);

// Save the modified image

imwrite("encoded_image.png", image);

// Load the modified image

Mat encodedImage = imread("encoded_image.png");

// Decode the message from the image

string decodedMessage = decodeMessage(encodedImage);

cout << "Decoded Message: " << decodedMessage << endl;

return 0;

}

Explanation Include Libraries: The program includes the OpenCV library for image processing and standard I/O libraries for handling input and output. Encode Message: Message Length Check: Verifies that the message can fit within the image. Convert Message to Binary: Converts each character of the message to an 8-bit binary representation and concatenates them. Add …

Image Steganography Gaming Project in C++ Read More »

Image Processing Basics Gaming Project in C++

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

#include <iostream>
#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;

int main() {
    // Load the image
    Mat image = imread("input.jpg");
    if (image.empty()) {
        cerr << "Error loading image!" << endl;
        return -1;
    }

    // Convert image to grayscale
    Mat grayImage;
    cvtColor(image, grayImage, COLOR_BGR2GRAY);

    // Apply Gaussian blur to the grayscale image
    Mat blurredImage;
    GaussianBlur(grayImage, blurredImage, Size(5, 5), 0);

    // Save the processed image
    if (!imwrite("output.jpg", blurredImage)) {
        cerr << "Error saving image!" << endl;
        return -1;
    }

    cout << "Image processing completed successfully." << endl;

    return 0;
}

#include <iostream>

#include <opencv2/opencv.hpp>

using namespace std;

using namespace cv;

int main() {

// Load the image

Mat image = imread("input.jpg");

if (image.empty()) {

cerr << "Error loading image!" << endl;

return -1;

}

// Convert image to grayscale

Mat grayImage;

cvtColor(image, grayImage, COLOR_BGR2GRAY);

// Apply Gaussian blur to the grayscale image

Mat blurredImage;

GaussianBlur(grayImage, blurredImage, Size(5, 5), 0);

// Save the processed image

if (!imwrite("output.jpg", blurredImage)) {

cerr << "Error saving image!" << endl;

return -1;

}

cout << "Image processing completed successfully." << endl;

return 0;

}

Explanation Include Libraries: The program includes the OpenCV library for image processing. OpenCV is a popular computer vision library that provides various functions for image manipulation. Load Image: The imread function loads an image from a specified file path into a Mat object. If the image cannot be loaded, an error message is displayed. …

Image Processing Basics Gaming Project in C++ Read More »

Hash Table Implementation Gaming Project in C++

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

#include <iostream>
#include <list>
#include <vector>
#include <iterator>
#include <algorithm>

using namespace std;

class HashTable {
private:
    vector<list<int>> table;
    int size;

    // Hash function to compute the index for a given key
    int hashFunction(int key) const {
        return key % size;
    }

public:
    HashTable(int s) : size(s) {
        table.resize(size);
    }

    // Insert a key into the hash table
    void insert(int key) {
        int index = hashFunction(key);
        auto& cell = table[index];
        // Check if the key already exists
        if (find(cell.begin(), cell.end(), key) == cell.end()) {
            cell.push_back(key);
        }
    }

    // Delete a key from the hash table
    void remove(int key) {
        int index = hashFunction(key);
        auto& cell = table[index];
        auto it = find(cell.begin(), cell.end(), key);
        if (it != cell.end()) {
            cell.erase(it);
        }
    }

    // Search for a key in the hash table
    bool search(int key) const {
        int index = hashFunction(key);
        const auto& cell = table[index];
        return find(cell.begin(), cell.end(), key) != cell.end();
    }

    // Display the hash table
    void display() const {
        for (int i = 0; i < size; ++i) {
            cout << "Bucket " << i << ": ";
            for (const int& key : table[i]) {
                cout << key << " -> ";
            }
            cout << "nullptr" << endl;
        }
    }
};

int main() {
    HashTable hashTable(10);

    hashTable.insert(10);
    hashTable.insert(20);
    hashTable.insert(30);
    hashTable.insert(40);
    hashTable.insert(50);

    cout << "Hash Table:" << endl;
    hashTable.display();

    cout << "\nSearching for 20: " << (hashTable.search(20) ? "Found" : "Not Found") << endl;
    cout << "Searching for 25: " << (hashTable.search(25) ? "Found" : "Not Found") << endl;

    hashTable.remove(20);
    cout << "\nHash Table after removing 20:" << endl;
    hashTable.display();

    return 0;
}

#include <iostream>

#include <list>

#include <vector>

#include <iterator>

#include <algorithm>

using namespace std;

class HashTable {

private:

vector<list<int>> table;

int size;

// Hash function to compute the index for a given key

int hashFunction(int key) const {

return key % size;

}

public:

HashTable(int s) : size(s) {

table.resize(size);

}

// Insert a key into the hash table

void insert(int key) {

int index = hashFunction(key);

auto& cell = table[index];

// Check if the key already exists

if (find(cell.begin(), cell.end(), key) == cell.end()) {

cell.push_back(key);

}

// Delete a key from the hash table

void remove(int key) {

int index = hashFunction(key);

auto& cell = table[index];

auto it = find(cell.begin(), cell.end(), key);

if (it != cell.end()) {

cell.erase(it);

}

// Search for a key in the hash table

bool search(int key) const {

int index = hashFunction(key);

const auto& cell = table[index];

return find(cell.begin(), cell.end(), key) != cell.end();

}

// Display the hash table

void display() const {

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

cout << "Bucket " << i << ": ";

for (const int& key : table[i]) {

cout << key << " -> ";

}

cout << "nullptr" << endl;

}

};

int main() {

HashTable hashTable(10);

hashTable.insert(10);

hashTable.insert(20);

hashTable.insert(30);

hashTable.insert(40);

hashTable.insert(50);

cout << "Hash Table:" << endl;

hashTable.display();

cout << "\nSearching for 20: " << (hashTable.search(20) ? "Found" : "Not Found") << endl;

cout << "Searching for 25: " << (hashTable.search(25) ? "Found" : "Not Found") << endl;

hashTable.remove(20);

cout << "\nHash Table after removing 20:" << endl;

hashTable.display();

return 0;

}

Explanation: Hash Table Structure: vector<list<int>> table;: The hash table is implemented as a vector of lists. Each list represents a bucket where keys with the same hash index are stored. int size;: The number of buckets in the hash table. Hash Function (hashFunction): int hashFunction(int key) const: Computes the index for a given key …

Hash Table Implementation Gaming Project in C++ Read More »

Hangman Game Gaming Project in C++

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

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

using namespace std;

// Function to display the current state of the guessed word
void displayWord(const string& word, const vector<bool>& guessed) {
    for (size_t i = 0; i < word.length(); ++i) {
        if (guessed[i]) {
            cout << word[i] << ' ';
        } else {
            cout << '_ ' ;
        }
    }
    cout << endl;
}

// Function to play the Hangman game
void playHangman(const string& word) {
    vector<bool> guessed(word.length(), false);
    int attempts = 6;
    string guessedLetters;
    
    cout << "Welcome to Hangman!" << endl;
    cout << "Guess the word: " << endl;
    
    while (attempts > 0) {
        displayWord(word, guessed);
        cout << "Attempts remaining: " << attempts << endl;
        cout << "Guess a letter: ";
        
        char guess;
        cin >> guess;
        
        if (guessedLetters.find(guess) != string::npos) {
            cout << "You already guessed that letter!" << endl;
            continue;
        }
        
        guessedLetters += guess;
        bool correctGuess = false;
        
        for (size_t i = 0; i < word.length(); ++i) {
            if (word[i] == guess) {
                guessed[i] = true;
                correctGuess = true;
            }
        }
        
        if (!correctGuess) {
            --attempts;
            cout << "Incorrect guess!" << endl;
        }
        
        // Check if the player has guessed the entire word
        if (all_of(guessed.begin(), guessed.end(), [](bool g) { return g; })) {
            cout << "Congratulations! You guessed the word: " << word << endl;
            return;
        }
    }
    
    cout << "Game over! The word was: " << word << endl;
}

int main() {
    string word;
    
    cout << "Enter the word for the Hangman game: ";
    cin >> word;
    transform(word.begin(), word.end(), word.begin(), ::toupper);  // Convert to uppercase

    playHangman(word);
    
    return 0;
}

#include <iostream>

#include <vector>

#include <string>

#include <algorithm>

using namespace std;

// Function to display the current state of the guessed word

void displayWord(const string& word, const vector<bool>& guessed) {

for (size_t i = 0; i < word.length(); ++i) {

if (guessed[i]) {

cout << word[i] << ' ';

} else {

cout << '_ ' ;

}

cout << endl;

}

// Function to play the Hangman game

void playHangman(const string& word) {

vector<bool> guessed(word.length(), false);

int attempts = 6;

string guessedLetters;

cout << "Welcome to Hangman!" << endl;

cout << "Guess the word: " << endl;

while (attempts > 0) {

displayWord(word, guessed);

cout << "Attempts remaining: " << attempts << endl;

cout << "Guess a letter: ";

char guess;

cin >> guess;

if (guessedLetters.find(guess) != string::npos) {

cout << "You already guessed that letter!" << endl;

continue;

}

guessedLetters += guess;

bool correctGuess = false;

for (size_t i = 0; i < word.length(); ++i) {

if (word[i] == guess) {

guessed[i] = true;

correctGuess = true;

}

if (!correctGuess) {

--attempts;

cout << "Incorrect guess!" << endl;

}

// Check if the player has guessed the entire word

if (all_of(guessed.begin(), guessed.end(), [](bool g) { return g; })) {

cout << "Congratulations! You guessed the word: " << word << endl;

return;

}

cout << "Game over! The word was: " << word << endl;

}

int main() {

string word;

cout << "Enter the word for the Hangman game: ";

cin >> word;

transform(word.begin(), word.end(), word.begin(), ::toupper); // Convert to uppercase

playHangman(word);

return 0;

}

Explanation: Display Word (displayWord): Shows the current state of the word with correctly guessed letters and underscores for unguessed letters. Play Hangman (playHangman): Initializes the guessed vector to track guessed letters and attempts to the maximum number of wrong guesses allowed. Loops until the player either guesses the word or runs out of attempts. …

Hangman Game Gaming Project in C++ Read More »

Handwriting Recognition Gaming Project in C++

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

#include <iostream>
#include <opencv2/opencv.hpp>
#include <opencv2/ml.hpp>

using namespace std;
using namespace cv;
using namespace cv::ml;

int main() {
    // Load the pre-trained KNN model
    Ptr<KNearest> knn = KNearest::create();
    knn->read("knn_model.xml");  // The model file should be pre-trained and saved

    // Load the handwritten digit image
    Mat img = imread("handwritten_digit.png", IMREAD_GRAYSCALE);
    if (img.empty()) {
        cerr << "Error loading image!" << endl;
        return -1;
    }

    // Preprocess the image
    Mat resized_img, flattened_img;
    resize(img, resized_img, Size(28, 28));  // Resize image to match training size
    resized_img.convertTo(resized_img, CV_32F);  // Convert to float for KNN
    flattened_img = resized_img.reshape(1, 1);  // Flatten to 1D vector

    // Predict the digit
    Mat result;
    knn->findNearest(flattened_img, 1, result);

    // Output the result
    cout << "Predicted digit: " << result.at<float>(0, 0) << endl;

    return 0;
}

#include <iostream>

#include <opencv2/opencv.hpp>

#include <opencv2/ml.hpp>

using namespace std;

using namespace cv;

using namespace cv::ml;

int main() {

// Load the pre-trained KNN model

Ptr<KNearest> knn = KNearest::create();

knn->read("knn_model.xml"); // The model file should be pre-trained and saved

// Load the handwritten digit image

Mat img = imread("handwritten_digit.png", IMREAD_GRAYSCALE);

if (img.empty()) {

cerr << "Error loading image!" << endl;

return -1;

}

// Preprocess the image

Mat resized_img, flattened_img;

resize(img, resized_img, Size(28, 28)); // Resize image to match training size

resized_img.convertTo(resized_img, CV_32F); // Convert to float for KNN

flattened_img = resized_img.reshape(1, 1); // Flatten to 1D vector

// Predict the digit

Mat result;

knn->findNearest(flattened_img, 1, result);

// Output the result

cout << "Predicted digit: " << result.at<float>(0, 0) << endl;

return 0;

}

Explanation: Dependencies: OpenCV is used for image processing and machine learning functions. You need to have OpenCV installed and properly linked with your project. Load Pre-trained Model: Ptr<KNearest> knn = KNearest::create(); creates a KNN object. knn->read(“knn_model.xml”); loads a pre-trained KNN model from an XML file. You need to have this model pre-trained and saved. …

Handwriting Recognition Gaming Project in C++ Read More »

Guess the Number Game Gaming Project in C++

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

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

using namespace std;

int main() {
    // Initialize random seed
    srand(static_cast<unsigned int>(time(0)));

    const int MIN = 1;
    const int MAX = 100;
    int targetNumber = rand() % (MAX - MIN + 1) + MIN;
    int guess;
    int attempts = 0;

    cout << "Welcome to 'Guess the Number' game!" << endl;
    cout << "I'm thinking of a number between " << MIN << " and " << MAX << "." << endl;

    do {
        cout << "Enter your guess: ";
        cin >> guess;
        ++attempts;

        if (guess > targetNumber) {
            cout << "Too high! Try again." << endl;
        } else if (guess < targetNumber) {
            cout << "Too low! Try again." << endl;
        } else {
            cout << "Congratulations! You guessed the number in " << attempts << " attempts." << endl;
        }
    } while (guess != targetNumber);

    return 0;
}

#include <iostream>

#include <cstdlib>

#include <ctime>

using namespace std;

int main() {

// Initialize random seed

srand(static_cast<unsigned int>(time(0)));

const int MIN = 1;

const int MAX = 100;

int targetNumber = rand() % (MAX - MIN + 1) + MIN;

int guess;

int attempts = 0;

cout << "Welcome to 'Guess the Number' game!" << endl;

cout << "I'm thinking of a number between " << MIN << " and " << MAX << "." << endl;

do {

cout << "Enter your guess: ";

cin >> guess;

++attempts;

if (guess > targetNumber) {

cout << "Too high! Try again." << endl;

} else if (guess < targetNumber) {

cout << "Too low! Try again." << endl;

} else {

cout << "Congratulations! You guessed the number in " << attempts << " attempts." << endl;

}

} while (guess != targetNumber);

return 0;

}

Explanation: Random Number Generation: srand(static_cast<unsigned int>(time(0))) seeds the random number generator with the current time to ensure different results on each run. rand() % (MAX – MIN + 1) + MIN generates a random number between MIN and MAX. Game Loop: The do-while loop continues until the player guesses the correct number. cin >> …

Guess the Number Game Gaming Project in C++ Read More »

Genetic Algorithm Simulation Gaming Project in C++

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

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

using namespace std;

const string TARGET = "HELLO WORLD";
const int POPULATION_SIZE = 100;
const int STRING_LENGTH = TARGET.length();
const double MUTATION_RATE = 0.01;
const int MAX_GENERATIONS = 1000;

// Function to generate a random candidate string
string generateRandomString() {
    string result;
    for (int i = 0; i < STRING_LENGTH; ++i) {
        result += static_cast<char>(rand() % 26 + 'A');
    }
    return result;
}

// Function to calculate fitness of a candidate string
int calculateFitness(const string& candidate) {
    int fitness = 0;
    for (int i = 0; i < STRING_LENGTH; ++i) {
        if (candidate[i] == TARGET[i]) {
            ++fitness;
        }
    }
    return fitness;
}

// Function to perform crossover between two parent strings
string crossover(const string& parent1, const string& parent2) {
    string child;
    int crossoverPoint = rand() % STRING_LENGTH;
    for (int i = 0; i < STRING_LENGTH; ++i) {
        child += (i < crossoverPoint) ? parent1[i] : parent2[i];
    }
    return child;
}

// Function to perform mutation on a candidate string
void mutate(string& candidate) {
    for (int i = 0; i < STRING_LENGTH; ++i) {
        if (static_cast<double>(rand()) / RAND_MAX < MUTATION_RATE) {
            candidate[i] = static_cast<char>(rand() % 26 + 'A');
        }
    }
}

// Main Genetic Algorithm function
void geneticAlgorithm() {
    vector<string> population(POPULATION_SIZE);
    vector<int> fitness(POPULATION_SIZE);

    // Initialize random seed
    srand(static_cast<unsigned int>(time(nullptr)));

    // Generate initial population
    for (int i = 0; i < POPULATION_SIZE; ++i) {
        population[i] = generateRandomString();
    }

    int generation = 0;
    while (generation < MAX_GENERATIONS) {
        // Calculate fitness for the population
        int bestFitness = 0;
        string bestCandidate;
        for (int i = 0; i < POPULATION_SIZE; ++i) {
            fitness[i] = calculateFitness(population[i]);
            if (fitness[i] > bestFitness) {
                bestFitness = fitness[i];
                bestCandidate = population[i];
            }
        }

        // Output the best candidate
        cout << "Generation " << generation << ": " << bestCandidate << " (Fitness: " << bestFitness << ")" << endl;
        if (bestFitness == STRING_LENGTH) {
            cout << "Target string reached!" << endl;
            break;
        }

        // Generate new population
        vector<string> newPopulation;
        while (newPopulation.size() < POPULATION_SIZE) {
            // Select parents
            int parent1Index = rand() % POPULATION_SIZE;
            int parent2Index = rand() % POPULATION_SIZE;

            // Perform crossover and mutation
            string child = crossover(population[parent1Index], population[parent2Index]);
            mutate(child);

            newPopulation.push_back(child);
        }

        population = newPopulation;
        ++generation;
    }
}

int main() {
    geneticAlgorithm();
    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

#include <iostream>

#include <vector>

#include <string>

#include <algorithm>

#include <ctime>

#include <cstdlib>

using namespace std;

const string TARGET = "HELLO WORLD";

const int POPULATION_SIZE = 100;

const int STRING_LENGTH = TARGET.length();

const double MUTATION_RATE = 0.01;

const int MAX_GENERATIONS = 1000;

// Function to generate a random candidate string

string generateRandomString() {

string result;

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

result += static_cast<char>(rand() % 26 + 'A');

}

return result;

}

// Function to calculate fitness of a candidate string

int calculateFitness(const string& candidate) {

int fitness = 0;

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

if (candidate[i] == TARGET[i]) {

++fitness;

}

return fitness;

}

// Function to perform crossover between two parent strings

string crossover(const string& parent1, const string& parent2) {

string child;

int crossoverPoint = rand() % STRING_LENGTH;

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

child += (i < crossoverPoint) ? parent1[i] : parent2[i];

}

return child;

}

// Function to perform mutation on a candidate string

void mutate(string& candidate) {

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

if (static_cast<double>(rand()) / RAND_MAX < MUTATION_RATE) {

candidate[i] = static_cast<char>(rand() % 26 + 'A');

}

// Main Genetic Algorithm function

void geneticAlgorithm() {

vector<string> population(POPULATION_SIZE);

vector<int> fitness(POPULATION_SIZE);

// Initialize random seed

srand(static_cast<unsigned int>(time(nullptr)));

// Generate initial population

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

population[i] = generateRandomString();

}

int generation = 0;

while (generation < MAX_GENERATIONS) {

// Calculate fitness for the population

int bestFitness = 0;

string bestCandidate;

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

fitness[i] = calculateFitness(population[i]);

if (fitness[i] > bestFitness) {

bestFitness = fitness[i];

bestCandidate = population[i];

}

// Output the best candidate

cout << "Generation " << generation << ": " << bestCandidate << " (Fitness: " << bestFitness << ")" << endl;

if (bestFitness == STRING_LENGTH) {

cout << "Target string reached!" << endl;

break;

}

// Generate new population

vector<string> newPopulation;

while (newPopulation.size() < POPULATION_SIZE) {

// Select parents

int parent1Index = rand() % POPULATION_SIZE;

int parent2Index = rand() % POPULATION_SIZE;

// Perform crossover and mutation

string child = crossover(population[parent1Index], population[parent2Index]);

mutate(child);

newPopulation.push_back(child);

}

population = newPopulation;

++generation;

}

int main() {

geneticAlgorithm();

return 0;

}

Explanation: Constants: TARGET: The target string to be matched by the genetic algorithm. POPULATION_SIZE: Number of candidate strings in each generation. STRING_LENGTH: Length of the target string. MUTATION_RATE: Probability of mutation in each gene (character). MAX_GENERATIONS: Maximum number of generations to run the algorithm. Generating Random Strings (generateRandomString): Creates a random string of uppercase …

Genetic Algorithm Simulation Gaming Project in C++ Read More »