C++ Projects – Page 4 – Projects Inventory

Simulation of File Allocation Methods Gaming Project in C++

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

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

class FileSystem {
public:
    FileSystem(int totalBlocks) : blocks(totalBlocks, false) {}

    // Contiguous Allocation
    bool allocateContiguous(int fileSize, int& startBlock) {
        for (int i = 0; i <= blocks.size() - fileSize; ++i) {
            bool canAllocate = true;
            for (int j = i; j < i + fileSize; ++j) {
                if (blocks[j]) {
                    canAllocate = false;
                    break;
                }
            }
            if (canAllocate) {
                startBlock = i;
                for (int j = i; j < i + fileSize; ++j) {
                    blocks[j] = true;
                }
                return true;
            }
        }
        return false;
    }

    // Linked Allocation
    bool allocateLinked(const std::vector<int>& fileBlocks, std::vector<int>& fileTable) {
        fileTable.clear();
        for (int block : fileBlocks) {
            if (block >= blocks.size() || blocks[block]) {
                return false;
            }
            blocks[block] = true;
            fileTable.push_back(block);
        }
        return true;
    }

    // Indexed Allocation
    bool allocateIndexed(const std::vector<int>& fileBlocks, std::vector<int>& indexTable) {
        indexTable.clear();
        for (int block : fileBlocks) {
            if (block >= blocks.size() || blocks[block]) {
                return false;
            }
            blocks[block] = true;
            indexTable.push_back(block);
        }
        return true;
    }

    void printBlocks() const {
        std::cout << "Block Status:\n";
        for (int i = 0; i < blocks.size(); ++i) {
            std::cout << "Block " << i << ": " << (blocks[i] ? "Allocated" : "Free") << "\n";
        }
    }

private:
    std::vector<bool> blocks;
};

int main() {
    int totalBlocks;
    std::cout << "Enter total number of blocks in the file system: ";
    std::cin >> totalBlocks;

    FileSystem fs(totalBlocks);

    int choice;
    std::cout << "Select allocation method:\n";
    std::cout << "1. Contiguous Allocation\n";
    std::cout << "2. Linked Allocation\n";
    std::cout << "3. Indexed Allocation\n";
    std::cout << "Enter choice (1-3): ";
    std::cin >> choice;

    if (choice == 1) {
        int fileSize, startBlock;
        std::cout << "Enter file size for contiguous allocation: ";
        std::cin >> fileSize;
        if (fs.allocateContiguous(fileSize, startBlock)) {
            std::cout << "File allocated starting at block " << startBlock << "\n";
        } else {
            std::cout << "Allocation failed. Not enough contiguous space.\n";
        }
    } else if (choice == 2) {
        int numBlocks;
        std::cout << "Enter number of blocks for linked allocation: ";
        std::cin >> numBlocks;
        std::vector<int> fileBlocks(numBlocks);
        std::cout << "Enter blocks for linked allocation: ";
        for (int& block : fileBlocks) {
            std::cin >> block;
        }
        std::vector<int> fileTable;
        if (fs.allocateLinked(fileBlocks, fileTable)) {
            std::cout << "File allocated with linked allocation.\n";
            std::cout << "File Table: ";
            for (int block : fileTable) {
                std::cout << block << " ";
            }
            std::cout << "\n";
        } else {
            std::cout << "Allocation failed. Invalid blocks or already allocated.\n";
        }
    } else if (choice == 3) {
        int numBlocks;
        std::cout << "Enter number of blocks for indexed allocation: ";
        std::cin >> numBlocks;
        std::vector<int> fileBlocks(numBlocks);
        std::cout << "Enter blocks for indexed allocation: ";
        for (int& block : fileBlocks) {
            std::cin >> block;
        }
        std::vector<int> indexTable;
        if (fs.allocateIndexed(fileBlocks, indexTable)) {
            std::cout << "File allocated with indexed allocation.\n";
            std::cout << "Index Table: ";
            for (int block : indexTable) {
                std::cout << block << " ";
            }
            std::cout << "\n";
        } else {
            std::cout << "Allocation failed. Invalid blocks or already allocated.\n";
        }
    } else {
        std::cout << "Invalid choice.\n";
    }

    fs.printBlocks();

    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

129

130

131

132

133

134

135

136

137

138

#include <iostream>

#include <vector>

#include <iomanip>

class FileSystem {

public:

FileSystem(int totalBlocks) : blocks(totalBlocks, false) {}

// Contiguous Allocation

bool allocateContiguous(int fileSize, int& startBlock) {

for (int i = 0; i <= blocks.size() - fileSize; ++i) {

bool canAllocate = true;

for (int j = i; j < i + fileSize; ++j) {

if (blocks[j]) {

canAllocate = false;

break;

}

if (canAllocate) {

startBlock = i;

for (int j = i; j < i + fileSize; ++j) {

blocks[j] = true;

}

return true;

}

return false;

}

// Linked Allocation

bool allocateLinked(const std::vector<int>& fileBlocks, std::vector<int>& fileTable) {

fileTable.clear();

for (int block : fileBlocks) {

if (block >= blocks.size() || blocks[block]) {

return false;

}

blocks[block] = true;

fileTable.push_back(block);

}

return true;

}

// Indexed Allocation

bool allocateIndexed(const std::vector<int>& fileBlocks, std::vector<int>& indexTable) {

indexTable.clear();

for (int block : fileBlocks) {

if (block >= blocks.size() || blocks[block]) {

return false;

}

blocks[block] = true;

indexTable.push_back(block);

}

return true;

}

void printBlocks() const {

std::cout << "Block Status:\n";

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

std::cout << "Block " << i << ": " << (blocks[i] ? "Allocated" : "Free") << "\n";

}

private:

std::vector<bool> blocks;

};

int main() {

int totalBlocks;

std::cout << "Enter total number of blocks in the file system: ";

std::cin >> totalBlocks;

FileSystem fs(totalBlocks);

int choice;

std::cout << "Select allocation method:\n";

std::cout << "1. Contiguous Allocation\n";

std::cout << "2. Linked Allocation\n";

std::cout << "3. Indexed Allocation\n";

std::cout << "Enter choice (1-3): ";

std::cin >> choice;

if (choice == 1) {

int fileSize, startBlock;

std::cout << "Enter file size for contiguous allocation: ";

std::cin >> fileSize;

if (fs.allocateContiguous(fileSize, startBlock)) {

std::cout << "File allocated starting at block " << startBlock << "\n";

} else {

std::cout << "Allocation failed. Not enough contiguous space.\n";

}

} else if (choice == 2) {

int numBlocks;

std::cout << "Enter number of blocks for linked allocation: ";

std::cin >> numBlocks;

std::vector<int> fileBlocks(numBlocks);

std::cout << "Enter blocks for linked allocation: ";

for (int& block : fileBlocks) {

std::cin >> block;

}

std::vector<int> fileTable;

if (fs.allocateLinked(fileBlocks, fileTable)) {

std::cout << "File allocated with linked allocation.\n";

std::cout << "File Table: ";

for (int block : fileTable) {

std::cout << block << " ";

}

std::cout << "\n";

} else {

std::cout << "Allocation failed. Invalid blocks or already allocated.\n";

}

} else if (choice == 3) {

int numBlocks;

std::cout << "Enter number of blocks for indexed allocation: ";

std::cin >> numBlocks;

std::vector<int> fileBlocks(numBlocks);

std::cout << "Enter blocks for indexed allocation: ";

for (int& block : fileBlocks) {

std::cin >> block;

}

std::vector<int> indexTable;

if (fs.allocateIndexed(fileBlocks, indexTable)) {

std::cout << "File allocated with indexed allocation.\n";

std::cout << "Index Table: ";

for (int block : indexTable) {

std::cout << block << " ";

}

std::cout << "\n";

} else {

std::cout << "Allocation failed. Invalid blocks or already allocated.\n";

}

} else {

std::cout << "Invalid choice.\n";

}

fs.printBlocks();

return 0;

}

Explanation Class FileSystem: Purpose: Simulates a file system with different file allocation methods. Attributes: blocks: Vector indicating the status of each block (allocated or free). Methods: allocateContiguous(int fileSize, int& startBlock): Allocates contiguous blocks for a file, if possible, and sets the start block. allocateLinked(const std::vector<int>& fileBlocks, std::vector<int>& fileTable): Allocates blocks for a file using …

Simulation of File Allocation Methods Gaming Project in C++ Read More »

Simulation of Error Detection and Correction Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <bitset>

// Function to calculate parity bits
std::bitset<7> encodeHamming(const std::bitset<4>& data) {
    std::bitset<7> encoded;

    // Set data bits
    encoded[2] = data[0];
    encoded[4] = data[1];
    encoded[5] = data[2];
    encoded[6] = data[3];

    // Calculate parity bits
    encoded[0] = encoded[2] ^ encoded[4] ^ encoded[6]; // p1
    encoded[1] = encoded[2] ^ encoded[5] ^ encoded[6]; // p2
    encoded[3] = encoded[4] ^ encoded[5] ^ encoded[6]; // p3

    return encoded;
}

// Function to decode and correct errors
std::bitset<4> decodeHamming(const std::bitset<7>& encoded) {
    std::bitset<4> data;
    
    // Calculate parity bits
    bool p1 = encoded[0];
    bool p2 = encoded[1];
    bool p3 = encoded[3];
    
    bool d1 = encoded[2];
    bool d2 = encoded[4];
    bool d3 = encoded[5];
    bool d4 = encoded[6];
    
    // Compute syndromes
    bool s1 = p1 ^ (d1 ^ d2 ^ d4);
    bool s2 = p2 ^ (d1 ^ d3 ^ d4);
    bool s3 = p3 ^ (d2 ^ d3 ^ d4);
    
    // Calculate error position
    int errorPos = s1 | (s2 << 1) | (s3 << 2);
    
    // Correct error if present
    if (errorPos) {
        std::cout << "Error detected at position: " << errorPos << "\n";
        if (errorPos <= 7) {
            encoded.flip(errorPos - 1); // Correct the error
        }
    }

    // Extract data bits
    data[0] = encoded[2];
    data[1] = encoded[4];
    data[2] = encoded[5];
    data[3] = encoded[6];

    return data;
}

int main() {
    std::bitset<4> data;
    std::cout << "Enter 4-bit data (e.g., 1010): ";
    std::cin >> data;

    // Encode the data
    std::bitset<7> encoded = encodeHamming(data);
    std::cout << "Encoded data: " << encoded << "\n";

    // Simulate transmission (Introduce a single-bit error for demonstration)
    std::bitset<7> received = encoded;
    int errorBit;
    std::cout << "Introduce a single-bit error (position 1-7, or 0 for no error): ";
    std::cin >> errorBit;
    if (errorBit > 0 && errorBit <= 7) {
        received.flip(errorBit - 1);
        std::cout << "Received data with error: " << received << "\n";
    }

    // Decode and correct the received data
    std::bitset<4> decoded = decodeHamming(received);
    std::cout << "Decoded data: " << decoded << "\n";

    return 0;
}

#include <iostream>

#include <vector>

#include <bitset>

// Function to calculate parity bits

std::bitset<7> encodeHamming(const std::bitset<4>& data) {

std::bitset<7> encoded;

// Set data bits

encoded[2] = data[0];

encoded[4] = data[1];

encoded[5] = data[2];

encoded[6] = data[3];

// Calculate parity bits

encoded[0] = encoded[2] ^ encoded[4] ^ encoded[6]; // p1

encoded[1] = encoded[2] ^ encoded[5] ^ encoded[6]; // p2

encoded[3] = encoded[4] ^ encoded[5] ^ encoded[6]; // p3

return encoded;

}

// Function to decode and correct errors

std::bitset<4> decodeHamming(const std::bitset<7>& encoded) {

std::bitset<4> data;

// Calculate parity bits

bool p1 = encoded[0];

bool p2 = encoded[1];

bool p3 = encoded[3];

bool d1 = encoded[2];

bool d2 = encoded[4];

bool d3 = encoded[5];

bool d4 = encoded[6];

// Compute syndromes

bool s1 = p1 ^ (d1 ^ d2 ^ d4);

bool s2 = p2 ^ (d1 ^ d3 ^ d4);

bool s3 = p3 ^ (d2 ^ d3 ^ d4);

// Calculate error position

int errorPos = s1 | (s2 << 1) | (s3 << 2);

// Correct error if present

if (errorPos) {

std::cout << "Error detected at position: " << errorPos << "\n";

if (errorPos <= 7) {

encoded.flip(errorPos - 1); // Correct the error

}

// Extract data bits

data[0] = encoded[2];

data[1] = encoded[4];

data[2] = encoded[5];

data[3] = encoded[6];

return data;

}

int main() {

std::bitset<4> data;

std::cout << "Enter 4-bit data (e.g., 1010): ";

std::cin >> data;

// Encode the data

std::bitset<7> encoded = encodeHamming(data);

std::cout << "Encoded data: " << encoded << "\n";

// Simulate transmission (Introduce a single-bit error for demonstration)

std::bitset<7> received = encoded;

int errorBit;

std::cout << "Introduce a single-bit error (position 1-7, or 0 for no error): ";

std::cin >> errorBit;

if (errorBit > 0 && errorBit <= 7) {

received.flip(errorBit - 1);

std::cout << "Received data with error: " << received << "\n";

}

// Decode and correct the received data

std::bitset<4> decoded = decodeHamming(received);

std::cout << "Decoded data: " << decoded << "\n";

return 0;

}

Explanation Function encodeHamming: Purpose: Encodes 4-bit data using the Hamming(7,4) code. Process: Sets the data bits in their positions. Calculates the parity bits (p1, p2, p3) and sets them accordingly. Returns the encoded 7-bit data. Function decodeHamming: Purpose: Decodes the 7-bit Hamming code and detects/corrects errors. Process: Calculates parity bits from the received data. …

Simulation of Error Detection and Correction Gaming Project in C++ Read More »

Simulation of Epidemic Spread Gaming Project in C++

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

#include <iostream>
#include <iomanip>

// Class representing the Epidemic Model
class EpidemicModel {
public:
    EpidemicModel(double initialSusceptible, double initialInfected, double initialRecovered,
                  double infectionRate, double recoveryRate, double timeStep)
        : susceptible(initialSusceptible), infected(initialInfected), recovered(initialRecovered),
          infectionRate(infectionRate), recoveryRate(recoveryRate), timeStep(timeStep) {}

    void simulate(double totalTime) {
        std::cout << std::fixed << std::setprecision(2);
        std::cout << "Time\tSusceptible\tInfected\tRecovered\n";

        for (double t = 0; t <= totalTime; t += timeStep) {
            // Output current state
            std::cout << t << "\t" << susceptible << "\t" << infected << "\t" << recovered << "\n";

            // Calculate changes
            double newInfections = infectionRate * susceptible * infected;
            double newRecoveries = recoveryRate * infected;

            // Update states
            susceptible -= newInfections * timeStep;
            infected += (newInfections - newRecoveries) * timeStep;
            recovered += newRecoveries * timeStep;

            // Ensure values remain within bounds
            if (susceptible < 0) susceptible = 0;
            if (infected < 0) infected = 0;
            if (recovered < 0) recovered = 0;
        }
    }

private:
    double susceptible;
    double infected;
    double recovered;
    double infectionRate;
    double recoveryRate;
    double timeStep;
};

int main() {
    double initialSusceptible, initialInfected, initialRecovered;
    double infectionRate, recoveryRate;
    double timeStep, totalTime;

    std::cout << "Enter initial number of susceptible individuals: ";
    std::cin >> initialSusceptible;

    std::cout << "Enter initial number of infected individuals: ";
    std::cin >> initialInfected;

    std::cout << "Enter initial number of recovered individuals: ";
    std::cin >> initialRecovered;

    std::cout << "Enter infection rate (per susceptible and infected): ";
    std::cin >> infectionRate;

    std::cout << "Enter recovery rate (per infected): ";
    std::cin >> recoveryRate;

    std::cout << "Enter time step (in days): ";
    std::cin >> timeStep;

    std::cout << "Enter total simulation time (in days): ";
    std::cin >> totalTime;

    EpidemicModel model(initialSusceptible, initialInfected, initialRecovered,
                        infectionRate, recoveryRate, timeStep);

    model.simulate(totalTime);

    return 0;
}

#include <iostream>

#include <iomanip>

// Class representing the Epidemic Model

class EpidemicModel {

public:

EpidemicModel(double initialSusceptible, double initialInfected, double initialRecovered,

double infectionRate, double recoveryRate, double timeStep)

: susceptible(initialSusceptible), infected(initialInfected), recovered(initialRecovered),

infectionRate(infectionRate), recoveryRate(recoveryRate), timeStep(timeStep) {}

void simulate(double totalTime) {

std::cout << std::fixed << std::setprecision(2);

std::cout << "Time\tSusceptible\tInfected\tRecovered\n";

for (double t = 0; t <= totalTime; t += timeStep) {

// Output current state

std::cout << t << "\t" << susceptible << "\t" << infected << "\t" << recovered << "\n";

// Calculate changes

double newInfections = infectionRate * susceptible * infected;

double newRecoveries = recoveryRate * infected;

// Update states

susceptible -= newInfections * timeStep;

infected += (newInfections - newRecoveries) * timeStep;

recovered += newRecoveries * timeStep;

// Ensure values remain within bounds

if (susceptible < 0) susceptible = 0;

if (infected < 0) infected = 0;

if (recovered < 0) recovered = 0;

}

private:

double susceptible;

double infected;

double recovered;

double infectionRate;

double recoveryRate;

double timeStep;

};

int main() {

double initialSusceptible, initialInfected, initialRecovered;

double infectionRate, recoveryRate;

double timeStep, totalTime;

std::cout << "Enter initial number of susceptible individuals: ";

std::cin >> initialSusceptible;

std::cout << "Enter initial number of infected individuals: ";

std::cin >> initialInfected;

std::cout << "Enter initial number of recovered individuals: ";

std::cin >> initialRecovered;

std::cout << "Enter infection rate (per susceptible and infected): ";

std::cin >> infectionRate;

std::cout << "Enter recovery rate (per infected): ";

std::cin >> recoveryRate;

std::cout << "Enter time step (in days): ";

std::cin >> timeStep;

std::cout << "Enter total simulation time (in days): ";

std::cin >> totalTime;

EpidemicModel model(initialSusceptible, initialInfected, initialRecovered,

infectionRate, recoveryRate, timeStep);

model.simulate(totalTime);

return 0;

}

Explanation Class EpidemicModel: Purpose: Simulates the spread of an epidemic over time. Attributes: susceptible: Number of susceptible individuals. infected: Number of infected individuals. recovered: Number of recovered individuals. infectionRate: Rate at which susceptible individuals get infected by contact with infected individuals. recoveryRate: Rate at which infected individuals recover. timeStep: Time interval for each simulation …

Simulation of Epidemic Spread Gaming Project in C++ Read More »

Simulation of Employee Performance Gaming Project in C++

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

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

class Employee {
public:
    Employee(const std::string& name, const std::vector<double>& performanceScores)
        : name(name), performanceScores(performanceScores) {}

    std::string getName() const { return name; }
    double getAverageScore() const {
        double sum = 0;
        for (double score : performanceScores) {
            sum += score;
        }
        return performanceScores.empty() ? 0 : sum / performanceScores.size();
    }

private:
    std::string name;
    std::vector<double> performanceScores;
};

int main() {
    int numEmployees;
    std::cout << "Enter the number of employees: ";
    std::cin >> numEmployees;

    std::vector<Employee> employees;

    for (int i = 0; i < numEmployees; ++i) {
        std::string name;
        int numCriteria;
        std::cout << "Enter name for employee " << i + 1 << ": ";
        std::cin.ignore();  // To ignore any newline character left in the buffer
        std::getline(std::cin, name);

        std::cout << "Enter the number of performance criteria for " << name << ": ";
        std::cin >> numCriteria;

        std::vector<double> performanceScores(numCriteria);
        for (int j = 0; j < numCriteria; ++j) {
            std::cout << "Enter score for criterion " << j + 1 << ": ";
            std::cin >> performanceScores[j];
        }

        employees.emplace_back(name, performanceScores);
    }

    std::cout << std::fixed << std::setprecision(2);
    std::cout << "\nEmployee Performance Report:\n";
    std::cout << "Name\tAverage Score\n";

    for (const auto& employee : employees) {
        std::cout << employee.getName() << "\t" << employee.getAverageScore() << "\n";
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <iomanip>

class Employee {

public:

Employee(const std::string& name, const std::vector<double>& performanceScores)

: name(name), performanceScores(performanceScores) {}

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

double getAverageScore() const {

double sum = 0;

for (double score : performanceScores) {

sum += score;

}

return performanceScores.empty() ? 0 : sum / performanceScores.size();

}

private:

std::string name;

std::vector<double> performanceScores;

};

int main() {

int numEmployees;

std::cout << "Enter the number of employees: ";

std::cin >> numEmployees;

std::vector<Employee> employees;

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

std::string name;

int numCriteria;

std::cout << "Enter name for employee " << i + 1 << ": ";

std::cin.ignore(); // To ignore any newline character left in the buffer

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

std::cout << "Enter the number of performance criteria for " << name << ": ";

std::cin >> numCriteria;

std::vector<double> performanceScores(numCriteria);

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

std::cout << "Enter score for criterion " << j + 1 << ": ";

std::cin >> performanceScores[j];

}

employees.emplace_back(name, performanceScores);

}

std::cout << std::fixed << std::setprecision(2);

std::cout << "\nEmployee Performance Report:\n";

std::cout << "Name\tAverage Score\n";

for (const auto& employee : employees) {

std::cout << employee.getName() << "\t" << employee.getAverageScore() << "\n";

}

return 0;

}

Explanation Class Employee: Purpose: Represents an employee and their performance evaluation. Attributes: name: Name of the employee. performanceScores: Vector storing performance scores for various criteria. Methods: getName(): Returns the employee’s name. getAverageScore(): Calculates and returns the average performance score based on the criteria scores. Main Function: Setup: Initializes a list of employees. Input: Prompts …

Simulation of Employee Performance Gaming Project in C++ Read More »

Simulation of Elevator System Gaming Project in C++

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

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

class Elevator {
public:
    Elevator(int numFloors) : currentFloor(0), numFloors(numFloors) {}

    void request(int floor) {
        if (floor < 0 || floor >= numFloors) {
            std::cerr << "Invalid floor request.\n";
            return;
        }
        if (floor != currentFloor) {
            requests.push(floor);
        }
    }

    void operate() {
        while (!requests.empty()) {
            int targetFloor = requests.front();
            requests.pop();

            moveToFloor(targetFloor);
        }
    }

private:
    int currentFloor;
    int numFloors;
    std::queue<int> requests;

    void moveToFloor(int targetFloor) {
        std::cout << "Moving from floor " << currentFloor << " to floor " << targetFloor << "\n";
        currentFloor = targetFloor;
    }
};

int main() {
    int numFloors = 5; // Number of floors in the building
    Elevator elevator(numFloors);

    int numRequests;
    std::cout << "Enter the number of floor requests: ";
    std::cin >> numRequests;

    for (int i = 0; i < numRequests; ++i) {
        int floor;
        std::cout << "Enter floor request " << i + 1 << ": ";
        std::cin >> floor;
        elevator.request(floor);
    }

    std::cout << "Starting elevator operation...\n";
    elevator.operate();

    return 0;
}

#include <iostream>

#include <vector>

#include <queue>

#include <algorithm>

class Elevator {

public:

Elevator(int numFloors) : currentFloor(0), numFloors(numFloors) {}

void request(int floor) {

if (floor < 0 || floor >= numFloors) {

std::cerr << "Invalid floor request.\n";

return;

}

if (floor != currentFloor) {

requests.push(floor);

}

void operate() {

while (!requests.empty()) {

int targetFloor = requests.front();

requests.pop();

moveToFloor(targetFloor);

}

private:

int currentFloor;

int numFloors;

std::queue<int> requests;

void moveToFloor(int targetFloor) {

std::cout << "Moving from floor " << currentFloor << " to floor " << targetFloor << "\n";

currentFloor = targetFloor;

}

};

int main() {

int numFloors = 5; // Number of floors in the building

Elevator elevator(numFloors);

int numRequests;

std::cout << "Enter the number of floor requests: ";

std::cin >> numRequests;

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

int floor;

std::cout << "Enter floor request " << i + 1 << ": ";

std::cin >> floor;

elevator.request(floor);

}

std::cout << "Starting elevator operation...\n";

elevator.operate();

return 0;

}

Explanation Class Elevator: Purpose: Simulates an elevator system handling floor requests. Attributes: currentFloor: The current floor of the elevator. numFloors: Total number of floors in the building. requests: Queue of requested floors. Methods: request(int floor): Adds a floor request to the queue if the floor is valid and different from the current floor. operate(): …

Simulation of Elevator System Gaming Project in C++ Read More »

Simulation of Edge Computing Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <string>
#include <queue>
#include <random>
#include <iomanip>

// Class representing a task
class Task {
public:
    Task(int id, int dataSize) : id(id), dataSize(dataSize), isCompleted(false) {}

    int getId() const { return id; }
    int getDataSize() const { return dataSize; }
    bool isTaskCompleted() const { return isCompleted; }
    void markAsCompleted() { isCompleted = true; }

private:
    int id;
    int dataSize;
    bool isCompleted;
};

// Class representing an edge device
class EdgeDevice {
public:
    EdgeDevice(int id) : id(id), taskQueue() {}

    int getId() const { return id; }

    void addTask(const Task& task) {
        taskQueue.push(task);
    }

    void processTasks() {
        while (!taskQueue.empty()) {
            Task task = taskQueue.front();
            taskQueue.pop();
            std::cout << "Edge Device " << id << " processing Task " << task.getId() << "\n";
            // Simulate task processing with a delay
            // Here we just mark the task as completed
            task.markAsCompleted();
        }
    }

private:
    int id;
    std::queue<Task> taskQueue;
};

// Class representing the central server
class CentralServer {
public:
    void addTask(const Task& task) {
        tasks.push_back(task);
    }

    void distributeTasks(std::vector<EdgeDevice>& edgeDevices) {
        std::cout << "Distributing tasks to edge devices...\n";
        std::default_random_engine generator;
        std::uniform_int_distribution<int> distribution(0, edgeDevices.size() - 1);

        for (auto& task : tasks) {
            int deviceIndex = distribution(generator);
            edgeDevices[deviceIndex].addTask(task);
            std::cout << "Task " << task.getId() << " assigned to Edge Device " << edgeDevices[deviceIndex].getId() << "\n";
        }
    }

private:
    std::vector<Task> tasks;
};

int main() {
    int numTasks = 5;
    int numDevices = 3;

    // Create tasks
    std::vector<Task> tasks;
    for (int i = 0; i < numTasks; ++i) {
        tasks.emplace_back(i, rand() % 100 + 1);  // Random data size between 1 and 100
    }

    // Create edge devices
    std::vector<EdgeDevice> edgeDevices;
    for (int i = 0; i < numDevices; ++i) {
        edgeDevices.emplace_back(i);
    }

    // Create central server and add tasks
    CentralServer server;
    for (const auto& task : tasks) {
        server.addTask(task);
    }

    // Distribute tasks to edge devices
    server.distributeTasks(edgeDevices);

    // Process tasks on edge devices
    std::cout << "Processing tasks on edge devices...\n";
    for (auto& device : edgeDevices) {
        device.processTasks();
    }

    return 0;
}

100

101

102

103

104

105

106

#include <iostream>

#include <vector>

#include <string>

#include <queue>

#include <random>

#include <iomanip>

// Class representing a task

class Task {

public:

Task(int id, int dataSize) : id(id), dataSize(dataSize), isCompleted(false) {}

int getId() const { return id; }

int getDataSize() const { return dataSize; }

bool isTaskCompleted() const { return isCompleted; }

void markAsCompleted() { isCompleted = true; }

private:

int id;

int dataSize;

bool isCompleted;

};

// Class representing an edge device

class EdgeDevice {

public:

EdgeDevice(int id) : id(id), taskQueue() {}

int getId() const { return id; }

void addTask(const Task& task) {

taskQueue.push(task);

}

void processTasks() {

while (!taskQueue.empty()) {

Task task = taskQueue.front();

taskQueue.pop();

std::cout << "Edge Device " << id << " processing Task " << task.getId() << "\n";

// Simulate task processing with a delay

// Here we just mark the task as completed

task.markAsCompleted();

}

private:

int id;

std::queue<Task> taskQueue;

};

// Class representing the central server

class CentralServer {

public:

void addTask(const Task& task) {

tasks.push_back(task);

}

void distributeTasks(std::vector<EdgeDevice>& edgeDevices) {

std::cout << "Distributing tasks to edge devices...\n";

std::default_random_engine generator;

std::uniform_int_distribution<int> distribution(0, edgeDevices.size() - 1);

for (auto& task : tasks) {

int deviceIndex = distribution(generator);

edgeDevices[deviceIndex].addTask(task);

std::cout << "Task " << task.getId() << " assigned to Edge Device " << edgeDevices[deviceIndex].getId() << "\n";

}

private:

std::vector<Task> tasks;

};

int main() {

int numTasks = 5;

int numDevices = 3;

// Create tasks

std::vector<Task> tasks;

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

tasks.emplace_back(i, rand() % 100 + 1); // Random data size between 1 and 100

}

// Create edge devices

std::vector<EdgeDevice> edgeDevices;

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

edgeDevices.emplace_back(i);

}

// Create central server and add tasks

CentralServer server;

for (const auto& task : tasks) {

server.addTask(task);

}

// Distribute tasks to edge devices

server.distributeTasks(edgeDevices);

// Process tasks on edge devices

std::cout << "Processing tasks on edge devices...\n";

for (auto& device : edgeDevices) {

device.processTasks();

}

return 0;

}

Explanation Class Task: Purpose: Represents a task with an ID and a data size. Attributes: id: Identifier for the task. dataSize: Size of the task’s data. isCompleted: Status of whether the task has been completed. Methods: getId(), getDataSize(): Accessors for task attributes. isTaskCompleted(): Checks if the task is completed. markAsCompleted(): Marks the task as …

Simulation of Edge Computing Gaming Project in C++ Read More »

Simulation of Predator-Prey Model Gaming Project in C++

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

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

class PredatorPreyModel {
public:
    PredatorPreyModel(double preyInitial, double predatorInitial,
                      double preyBirthRate, double predatorDeathRate,
                      double predationRate, double reproductionRate,
                      double timeStep)
        : prey(preyInitial), predator(predatorInitial),
          preyBirthRate(preyBirthRate), predatorDeathRate(predatorDeathRate),
          predationRate(predationRate), reproductionRate(reproductionRate),
          timeStep(timeStep) {}

    void simulate(double totalTime) {
        std::cout << std::fixed << std::setprecision(2);
        std::cout << "Time\tPrey\tPredators\n";

        for (double t = 0; t <= totalTime; t += timeStep) {
            // Output current state
            std::cout << t << "\t" << prey << "\t" << predator << "\n";
            
            // Update populations
            double preyChange = preyBirthRate * prey - predationRate * prey * predator;
            double predatorChange = reproductionRate * prey * predator - predatorDeathRate * predator;
            
            prey += preyChange * timeStep;
            predator += predatorChange * timeStep;
        }
    }

private:
    double prey;
    double predator;
    double preyBirthRate;
    double predatorDeathRate;
    double predationRate;
    double reproductionRate;
    double timeStep;
};

int main() {
    double preyInitial, predatorInitial;
    double preyBirthRate, predatorDeathRate;
    double predationRate, reproductionRate;
    double timeStep, totalTime;

    std::cout << "Enter initial prey population: ";
    std::cin >> preyInitial;

    std::cout << "Enter initial predator population: ";
    std::cin >> predatorInitial;

    std::cout << "Enter prey birth rate: ";
    std::cin >> preyBirthRate;

    std::cout << "Enter predator death rate: ";
    std::cin >> predatorDeathRate;

    std::cout << "Enter predation rate: ";
    std::cin >> predationRate;

    std::cout << "Enter reproduction rate: ";
    std::cin >> reproductionRate;

    std::cout << "Enter time step: ";
    std::cin >> timeStep;

    std::cout << "Enter total simulation time: ";
    std::cin >> totalTime;

    PredatorPreyModel model(preyInitial, predatorInitial, preyBirthRate,
                            predatorDeathRate, predationRate, reproductionRate, timeStep);

    model.simulate(totalTime);

    return 0;
}

#include <iostream>

#include <vector>

#include <iomanip>

class PredatorPreyModel {

public:

PredatorPreyModel(double preyInitial, double predatorInitial,

double preyBirthRate, double predatorDeathRate,

double predationRate, double reproductionRate,

double timeStep)

: prey(preyInitial), predator(predatorInitial),

preyBirthRate(preyBirthRate), predatorDeathRate(predatorDeathRate),

predationRate(predationRate), reproductionRate(reproductionRate),

timeStep(timeStep) {}

void simulate(double totalTime) {

std::cout << std::fixed << std::setprecision(2);

std::cout << "Time\tPrey\tPredators\n";

for (double t = 0; t <= totalTime; t += timeStep) {

// Output current state

std::cout << t << "\t" << prey << "\t" << predator << "\n";

// Update populations

double preyChange = preyBirthRate * prey - predationRate * prey * predator;

double predatorChange = reproductionRate * prey * predator - predatorDeathRate * predator;

prey += preyChange * timeStep;

predator += predatorChange * timeStep;

}

private:

double prey;

double predator;

double preyBirthRate;

double predatorDeathRate;

double predationRate;

double reproductionRate;

double timeStep;

};

int main() {

double preyInitial, predatorInitial;

double preyBirthRate, predatorDeathRate;

double predationRate, reproductionRate;

double timeStep, totalTime;

std::cout << "Enter initial prey population: ";

std::cin >> preyInitial;

std::cout << "Enter initial predator population: ";

std::cin >> predatorInitial;

std::cout << "Enter prey birth rate: ";

std::cin >> preyBirthRate;

std::cout << "Enter predator death rate: ";

std::cin >> predatorDeathRate;

std::cout << "Enter predation rate: ";

std::cin >> predationRate;

std::cout << "Enter reproduction rate: ";

std::cin >> reproductionRate;

std::cout << "Enter time step: ";

std::cin >> timeStep;

std::cout << "Enter total simulation time: ";

std::cin >> totalTime;

PredatorPreyModel model(preyInitial, predatorInitial, preyBirthRate,

predatorDeathRate, predationRate, reproductionRate, timeStep);

model.simulate(totalTime);

return 0;

}

Explanation Class PredatorPreyModel: Purpose: Simulates the dynamics of predator and prey populations using the Lotka-Volterra equations. Attributes: prey: Current population of prey. predator: Current population of predators. preyBirthRate: Birth rate of prey. predatorDeathRate: Death rate of predators. predationRate: Rate at which predators kill prey. reproductionRate: Rate at which predators reproduce based on prey. timeStep: …

Simulation of Predator-Prey Model Gaming Project in C++ Read More »

Simulation of Predictive Analytics Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <numeric>
#include <cmath>

// Function to calculate the mean of a vector
double mean(const std::vector<double>& data) {
    return std::accumulate(data.begin(), data.end(), 0.0) / data.size();
}

// Function to calculate the slope (m) and intercept (b) of the linear regression line
void linearRegression(const std::vector<double>& x, const std::vector<double>& y, double& slope, double& intercept) {
    size_t n = x.size();
    double x_mean = mean(x);
    double y_mean = mean(y);

    double numerator = 0.0;
    double denominator = 0.0;

    for (size_t i = 0; i < n; ++i) {
        numerator += (x[i] - x_mean) * (y[i] - y_mean);
        denominator += (x[i] - x_mean) * (x[i] - x_mean);
    }

    slope = numerator / denominator;
    intercept = y_mean - slope * x_mean;
}

// Function to predict a value based on the linear regression model
double predict(double x, double slope, double intercept) {
    return slope * x + intercept;
}

int main() {
    // Example data: x values (e.g., months) and y values (e.g., sales)
    std::vector<double> x = {1, 2, 3, 4, 5};  // Example x values
    std::vector<double> y = {2, 3, 5, 7, 11}; // Example y values (corresponding to x values)

    double slope, intercept;
    linearRegression(x, y, slope, intercept);

    std::cout << "Linear Regression Model:\n";
    std::cout << "Slope (m): " << slope << std::endl;
    std::cout << "Intercept (b): " << intercept << std::endl;

    double x_predict;
    std::cout << "Enter a value for x to predict its corresponding y: ";
    std::cin >> x_predict;

    double y_predict = predict(x_predict, slope, intercept);
    std::cout << "Predicted y for x = " << x_predict << " is " << y_predict << std::endl;

    return 0;
}

#include <iostream>

#include <vector>

#include <numeric>

#include <cmath>

// Function to calculate the mean of a vector

double mean(const std::vector<double>& data) {

return std::accumulate(data.begin(), data.end(), 0.0) / data.size();

}

// Function to calculate the slope (m) and intercept (b) of the linear regression line

void linearRegression(const std::vector<double>& x, const std::vector<double>& y, double& slope, double& intercept) {

size_t n = x.size();

double x_mean = mean(x);

double y_mean = mean(y);

double numerator = 0.0;

double denominator = 0.0;

for (size_t i = 0; i < n; ++i) {

numerator += (x[i] - x_mean) * (y[i] - y_mean);

denominator += (x[i] - x_mean) * (x[i] - x_mean);

}

slope = numerator / denominator;

intercept = y_mean - slope * x_mean;

}

// Function to predict a value based on the linear regression model

double predict(double x, double slope, double intercept) {

return slope * x + intercept;

}

int main() {

// Example data: x values (e.g., months) and y values (e.g., sales)

std::vector<double> x = {1, 2, 3, 4, 5}; // Example x values

std::vector<double> y = {2, 3, 5, 7, 11}; // Example y values (corresponding to x values)

double slope, intercept;

linearRegression(x, y, slope, intercept);

std::cout << "Linear Regression Model:\n";

std::cout << "Slope (m): " << slope << std::endl;

std::cout << "Intercept (b): " << intercept << std::endl;

double x_predict;

std::cout << "Enter a value for x to predict its corresponding y: ";

std::cin >> x_predict;

double y_predict = predict(x_predict, slope, intercept);

std::cout << "Predicted y for x = " << x_predict << " is " << y_predict << std::endl;

return 0;

}

Explanation Function mean(const std::vector<double>& data): Purpose: Computes the mean of a dataset. Implementation: Uses std::accumulate to sum the data and divides by the number of elements. Function linearRegression(const std::vector<double>& x, const std::vector<double>& y, double& slope, double& intercept): Purpose: Calculates the slope and intercept of the linear regression line. Parameters: x: Vector of independent variable …

Simulation of Predictive Analytics Gaming Project in C++ Read More »

Simulation of Project in C++ Management Gaming Project in C++

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

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

class Task {
public:
    Task(const std::string& name, const std::string& assignedTo, int priority)
        : name(name), assignedTo(assignedTo), priority(priority), isComplete(false) {}

    void markComplete() {
        isComplete = true;
    }

    void print() const {
        std::cout << std::setw(20) << std::left << name
                  << std::setw(20) << std::left << assignedTo
                  << std::setw(10) << std::left << priority
                  << (isComplete ? "Complete" : "Incomplete") << std::endl;
    }

private:
    std::string name;
    std::string assignedTo;
    int priority;
    bool isComplete;
};

class Project {
public:
    void addTask(const std::string& name, const std::string& assignedTo, int priority) {
        tasks.emplace_back(name, assignedTo, priority);
    }

    void markTaskComplete(int index) {
        if (index >= 0 && index < tasks.size()) {
            tasks[index].markComplete();
        } else {
            std::cerr << "Error: Invalid task index." << std::endl;
        }
    }

    void printTasks() const {
        std::cout << std::setw(20) << std::left << "Task Name"
                  << std::setw(20) << std::left << "Assigned To"
                  << std::setw(10) << std::left << "Priority"
                  << "Status" << std::endl;
        for (const auto& task : tasks) {
            task.print();
        }
    }

private:
    std::vector<Task> tasks;
};

int main() {
    Project project;

    int choice;
    do {
        std::cout << "\nProject Management Simulation\n";
        std::cout << "1. Add Task\n";
        std::cout << "2. Mark Task Complete\n";
        std::cout << "3. Print Tasks\n";
        std::cout << "4. Exit\n";
        std::cout << "Enter your choice: ";
        std::cin >> choice;
        std::cin.ignore();  // To ignore the newline character after integer input

        if (choice == 1) {
            std::string name, assignedTo;
            int priority;
            std::cout << "Enter task name: ";
            std::getline(std::cin, name);
            std::cout << "Enter assigned to: ";
            std::getline(std::cin, assignedTo);
            std::cout << "Enter priority (1-10): ";
            std::cin >> priority;
            std::cin.ignore();  // To ignore the newline character after integer input
            project.addTask(name, assignedTo, priority);
        } else if (choice == 2) {
            int index;
            std::cout << "Enter task index to mark as complete: ";
            std::cin >> index;
            project.markTaskComplete(index);
        } else if (choice == 3) {
            project.printTasks();
        } else if (choice == 4) {
            std::cout << "Exiting program.\n";
        } else {
            std::cerr << "Invalid choice. Please try again.\n";
        }
    } while (choice != 4);

    return 0;
}

#include <iostream>

#include <vector>

#include <string>

#include <iomanip>

class Task {

public:

Task(const std::string& name, const std::string& assignedTo, int priority)

: name(name), assignedTo(assignedTo), priority(priority), isComplete(false) {}

void markComplete() {

isComplete = true;

}

void print() const {

std::cout << std::setw(20) << std::left << name

<< std::setw(20) << std::left << assignedTo

<< std::setw(10) << std::left << priority

<< (isComplete ? "Complete" : "Incomplete") << std::endl;

}

private:

std::string name;

std::string assignedTo;

int priority;

bool isComplete;

};

class Project {

public:

void addTask(const std::string& name, const std::string& assignedTo, int priority) {

tasks.emplace_back(name, assignedTo, priority);

}

void markTaskComplete(int index) {

if (index >= 0 && index < tasks.size()) {

tasks[index].markComplete();

} else {

std::cerr << "Error: Invalid task index." << std::endl;

}

void printTasks() const {

std::cout << std::setw(20) << std::left << "Task Name"

<< std::setw(20) << std::left << "Assigned To"

<< std::setw(10) << std::left << "Priority"

<< "Status" << std::endl;

for (const auto& task : tasks) {

task.print();

}

private:

std::vector<Task> tasks;

};

int main() {

Project project;

int choice;

do {

std::cout << "\nProject Management Simulation\n";

std::cout << "1. Add Task\n";

std::cout << "2. Mark Task Complete\n";

std::cout << "3. Print Tasks\n";

std::cout << "4. Exit\n";

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

std::cin >> choice;

std::cin.ignore(); // To ignore the newline character after integer input

if (choice == 1) {

std::string name, assignedTo;

int priority;

std::cout << "Enter task name: ";

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

std::cout << "Enter assigned to: ";

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

std::cout << "Enter priority (1-10): ";

std::cin >> priority;

std::cin.ignore(); // To ignore the newline character after integer input

project.addTask(name, assignedTo, priority);

} else if (choice == 2) {

int index;

std::cout << "Enter task index to mark as complete: ";

std::cin >> index;

project.markTaskComplete(index);

} else if (choice == 3) {

project.printTasks();

} else if (choice == 4) {

std::cout << "Exiting program.\n";

} else {

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

}

} while (choice != 4);

return 0;

}

Explanation Class Task: Purpose: Represents a single task within a project. Attributes: name: Name of the task. assignedTo: Person responsible for the task. priority: Priority level of the task (e.g., 1-10). isComplete: Status indicating whether the task is complete. Methods: markComplete(): Marks the task as complete. print(): Prints task details in a formatted manner. …

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

Simulation of Project in C++ile Motion Gaming Project in C++

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

#include <iostream>
#include <cmath>
#include <iomanip>

const double GRAVITY = 9.81; // Acceleration due to gravity (m/s^2)

// Function to simulate projectile motion
void simulateProjectile(double velocity, double angle, double timeStep, int numSteps) {
    double angleRad = angle * M_PI / 180.0; // Convert angle to radians
    double initialX = 0.0; // Initial x position
    double initialY = 0.0; // Initial y position
    double velocityX = velocity * cos(angleRad); // Initial x velocity
    double velocityY = velocity * sin(angleRad); // Initial y velocity

    std::cout << "Time (s)\tX (m)\tY (m)\n";
    std::cout << std::fixed << std::setprecision(2);

    for (int step = 0; step <= numSteps; ++step) {
        double time = step * timeStep;
        double x = initialX + velocityX * time;
        double y = initialY + velocityY * time - 0.5 * GRAVITY * time * time;

        // Check if the projectile has hit the ground
        if (y < 0) {
            y = 0;
            std::cout << time << "\t" << x << "\t" << y << " (Ground)\n";
            break;
        }

        std::cout << time << "\t" << x << "\t" << y << "\n";
    }
}

int main() {
    double velocity, angle, timeStep;
    int numSteps;

    std::cout << "Enter the initial velocity (m/s): ";
    std::cin >> velocity;

    std::cout << "Enter the launch angle (degrees): ";
    std::cin >> angle;

    std::cout << "Enter the time step (s): ";
    std::cin >> timeStep;

    std::cout << "Enter the number of steps: ";
    std::cin >> numSteps;

    std::cout << "Projectile Motion Simulation\n";
    simulateProjectile(velocity, angle, timeStep, numSteps);

    return 0;
}

#include <iostream>

#include <cmath>

#include <iomanip>

const double GRAVITY = 9.81; // Acceleration due to gravity (m/s^2)

// Function to simulate projectile motion

void simulateProjectile(double velocity, double angle, double timeStep, int numSteps) {

double angleRad = angle * M_PI / 180.0; // Convert angle to radians

double initialX = 0.0; // Initial x position

double initialY = 0.0; // Initial y position

double velocityX = velocity * cos(angleRad); // Initial x velocity

double velocityY = velocity * sin(angleRad); // Initial y velocity

std::cout << "Time (s)\tX (m)\tY (m)\n";

std::cout << std::fixed << std::setprecision(2);

for (int step = 0; step <= numSteps; ++step) {

double time = step * timeStep;

double x = initialX + velocityX * time;

double y = initialY + velocityY * time - 0.5 * GRAVITY * time * time;

// Check if the projectile has hit the ground

if (y < 0) {

y = 0;

std::cout << time << "\t" << x << "\t" << y << " (Ground)\n";

break;

}

std::cout << time << "\t" << x << "\t" << y << "\n";

}

int main() {

double velocity, angle, timeStep;

int numSteps;

std::cout << "Enter the initial velocity (m/s): ";

std::cin >> velocity;

std::cout << "Enter the launch angle (degrees): ";

std::cin >> angle;

std::cout << "Enter the time step (s): ";

std::cin >> timeStep;

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

std::cin >> numSteps;

std::cout << "Projectile Motion Simulation\n";

simulateProjectile(velocity, angle, timeStep, numSteps);

return 0;

}

Explanation Constants: GRAVITY: The acceleration due to gravity (9.81 m/s²). Function simulateProjectile(double velocity, double angle, double timeStep, int numSteps): Purpose: Simulates the trajectory of a projectile. Parameters: velocity: Initial velocity of the projectile (m/s). angle: Launch angle of the projectile (degrees). timeStep: Time interval between each step of the simulation (s). numSteps: Number of …

Simulation of Project in C++ile Motion Gaming Project in C++ Read More »