Projects Inventory – Page 148 – Projects Inventory Management Systems and Source Codes PHP, C#, C, Android and many others

Encryption/Decryption Algorithm Gaming Project in C++

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

#include <iostream>
#include <string>

using namespace std;

// Function to encrypt a message using Caesar cipher
string encrypt(const string& message, int shift) {
    string encryptedMessage = message;

    for (char& c : encryptedMessage) {
        if (isalpha(c)) {
            char base = islower(c) ? 'a' : 'A';
            c = (c - base + shift) % 26 + base;
        }
    }

    return encryptedMessage;
}

// Function to decrypt a message using Caesar cipher
string decrypt(const string& message, int shift) {
    return encrypt(message, 26 - shift); // Decryption is encryption with (26 - shift)
}

int main() {
    string message;
    int shift;

    cout << "Enter the message to encrypt: ";
    getline(cin, message);

    cout << "Enter the shift value (1-25): ";
    cin >> shift;

    if (shift < 1 || shift > 25) {
        cout << "Invalid shift value. It should be between 1 and 25." << endl;
        return 1;
    }

    // Encrypt the message
    string encryptedMessage = encrypt(message, shift);
    cout << "Encrypted message: " << encryptedMessage << endl;

    // Decrypt the message
    string decryptedMessage = decrypt(encryptedMessage, shift);
    cout << "Decrypted message: " << decryptedMessage << endl;

    return 0;
}

#include <iostream>

#include <string>

using namespace std;

// Function to encrypt a message using Caesar cipher

string encrypt(const string& message, int shift) {

string encryptedMessage = message;

for (char& c : encryptedMessage) {

if (isalpha(c)) {

char base = islower(c) ? 'a' : 'A';

c = (c - base + shift) % 26 + base;

}

return encryptedMessage;

}

// Function to decrypt a message using Caesar cipher

string decrypt(const string& message, int shift) {

return encrypt(message, 26 - shift); // Decryption is encryption with (26 - shift)

}

int main() {

string message;

int shift;

cout << "Enter the message to encrypt: ";

getline(cin, message);

cout << "Enter the shift value (1-25): ";

cin >> shift;

if (shift < 1 || shift > 25) {

cout << "Invalid shift value. It should be between 1 and 25." << endl;

return 1;

}

// Encrypt the message

string encryptedMessage = encrypt(message, shift);

cout << "Encrypted message: " << encryptedMessage << endl;

// Decrypt the message

string decryptedMessage = decrypt(encryptedMessage, shift);

cout << "Decrypted message: " << decryptedMessage << endl;

return 0;

}

Explanation: Caesar Cipher Encryption (encrypt): The encrypt function shifts each letter in the input message by a specified number of positions in the alphabet. It loops through each character in the message: If the character is a letter, it calculates its new position by shifting it and wraps around the end of the alphabet …

Encryption/Decryption Algorithm Gaming Project in C++ Read More »

Functional requirements of Billing System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements User Authentication and Authorization Allow users (e.g., customers, billing staff, administrators) to create accounts, log in, and manage their profiles. Implement role-based access control to restrict access based on user roles (e.g., admin, billing clerk, customer). Invoice Generation Generate invoices for goods or services, including itemized details, quantities, prices, taxes, and total amounts. …

Functional requirements of Billing System with non-functional Read More »

Employee Payroll System Gaming Project in C++

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

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

using namespace std;

// Employee class to store employee details and salary calculation
class Employee {
public:
    Employee(const string& name, double hourlyRate, int hoursWorked)
        : name(name), hourlyRate(hourlyRate), hoursWorked(hoursWorked) {}

    double calculateSalary() const {
        return hourlyRate * hoursWorked;
    }

    void display() const {
        cout << "Name: " << name << endl
             << "Hourly Rate: $" << fixed << setprecision(2) << hourlyRate << endl
             << "Hours Worked: " << hoursWorked << endl
             << "Salary: $" << fixed << setprecision(2) << calculateSalary() << endl
             << "--------------------------" << endl;
    }

private:
    string name;
    double hourlyRate;
    int hoursWorked;
};

// Function to add an employee
void addEmployee(vector<Employee>& employees) {
    string name;
    double hourlyRate;
    int hoursWorked;

    cout << "Enter employee name: ";
    cin.ignore();
    getline(cin, name);
    cout << "Enter hourly rate: $";
    cin >> hourlyRate;
    cout << "Enter hours worked: ";
    cin >> hoursWorked;

    employees.emplace_back(name, hourlyRate, hoursWorked);
    cout << "Employee added successfully!" << endl;
}

// Function to display all employees' payroll
void displayPayroll(const vector<Employee>& employees) {
    cout << "Employee Payroll:" << endl;
    for (const auto& employee : employees) {
        employee.display();
    }
}

int main() {
    vector<Employee> employees;
    int choice;

    do {
        cout << "Employee Payroll System Menu:" << endl;
        cout << "1. Add Employee" << endl;
        cout << "2. Display Payroll" << endl;
        cout << "3. Exit" << endl;
        cout << "Enter your choice: ";
        cin >> choice;

        switch (choice) {
            case 1:
                addEmployee(employees);
                break;
            case 2:
                displayPayroll(employees);
                break;
            case 3:
                cout << "Exiting the system." << endl;
                break;
            default:
                cout << "Invalid choice. Please try again." << endl;
        }
    } while (choice != 3);

    return 0;
}

#include <iostream>

#include <vector>

#include <iomanip>

using namespace std;

// Employee class to store employee details and salary calculation

class Employee {

public:

Employee(const string& name, double hourlyRate, int hoursWorked)

: name(name), hourlyRate(hourlyRate), hoursWorked(hoursWorked) {}

double calculateSalary() const {

return hourlyRate * hoursWorked;

}

void display() const {

cout << "Name: " << name << endl

<< "Hourly Rate: $" << fixed << setprecision(2) << hourlyRate << endl

<< "Hours Worked: " << hoursWorked << endl

<< "Salary: $" << fixed << setprecision(2) << calculateSalary() << endl

<< "--------------------------" << endl;

}

private:

string name;

double hourlyRate;

int hoursWorked;

};

// Function to add an employee

void addEmployee(vector<Employee>& employees) {

string name;

double hourlyRate;

int hoursWorked;

cout << "Enter employee name: ";

cin.ignore();

getline(cin, name);

cout << "Enter hourly rate: $";

cin >> hourlyRate;

cout << "Enter hours worked: ";

cin >> hoursWorked;

employees.emplace_back(name, hourlyRate, hoursWorked);

cout << "Employee added successfully!" << endl;

}

// Function to display all employees' payroll

void displayPayroll(const vector<Employee>& employees) {

cout << "Employee Payroll:" << endl;

for (const auto& employee : employees) {

employee.display();

}

int main() {

vector<Employee> employees;

int choice;

do {

cout << "Employee Payroll System Menu:" << endl;

cout << "1. Add Employee" << endl;

cout << "2. Display Payroll" << endl;

cout << "3. Exit" << endl;

cout << "Enter your choice: ";

cin >> choice;

switch (choice) {

case 1:

addEmployee(employees);

break;

case 2:

displayPayroll(employees);

break;

case 3:

cout << "Exiting the system." << endl;

break;

default:

cout << "Invalid choice. Please try again." << endl;

}

} while (choice != 3);

return 0;

}

Explanation: Employee Class: The Employee class stores information about an employee, including their name, hourly rate, and hours worked. The calculateSalary method computes the employee’s salary based on their hourly rate and hours worked. The display method prints the employee’s details and calculated salary. Add Employee (addEmployee): This function prompts the user to input …

Employee Payroll System Gaming Project in C++ Read More »

Functional requirements of Exam Scheduling System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements User Authentication and Authorization Allow students, instructors, and administrators to create accounts, log in, and manage their profiles. Implement role-based access control to restrict access based on user roles (e.g., students, instructors, admins). Exam Scheduling Enable administrators to create and manage exam schedules, including setting dates, times, and locations. Allow instructors to propose …

Functional requirements of Exam Scheduling System with non-functional Read More »

Functional requirements of Visitor Management System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements Visitor Registration and Check-In Allow visitors to register upon arrival, either through a kiosk, tablet, or online portal. Capture visitor details such as name, contact information, purpose of visit, and check-in time. Provide options for pre-registration to expedite the check-in process. Identification Verification Verify visitor identity through various methods, such as scanning ID …

Functional requirements of Visitor Management System with non-functional Read More »

Functional requirements of Online Learning Management System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements User Authentication and Authorization Allow users (students, instructors, and administrators) to create accounts, log in, and manage their profiles. Implement role-based access control with permissions for different user roles (e.g., students, instructors, admins). Course Management Enable instructors to create, update, and manage courses, including course content, assignments, and assessments. Support course categories, descriptions, …

Functional requirements of Online Learning Management System with non-functional Read More »

Drawing Application Gaming Project in C++

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

#include <SFML/Graphics.hpp>
#include <vector>

using namespace std;

int main() {
    // Create a window
    sf::RenderWindow window(sf::VideoMode(800, 600), "Simple Drawing Application");

    // Vector to hold drawn lines
    vector<sf::VertexArray> lines;

    // Create a vertex array for the current line being drawn
    sf::VertexArray currentLine(sf::LinesStrip);

    bool isDrawing = false;

    while (window.isOpen()) {
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed) {
                window.close();
            }
        }

        // Check if the mouse is pressed
        if (sf::Mouse::isButtonPressed(sf::Mouse::Left)) {
            if (!isDrawing) {
                isDrawing = true;
                currentLine.clear();
                currentLine.append(sf::Vertex(sf::Vector2f(sf::Mouse::getPosition(window)), sf::Color::Red));
            } else {
                currentLine.append(sf::Vertex(sf::Vector2f(sf::Mouse::getPosition(window)), sf::Color::Red));
            }
        } else {
            if (isDrawing) {
                isDrawing = false;
                lines.push_back(currentLine);
                currentLine.clear();
            }
        }

        // Clear the window
        window.clear(sf::Color::White);

        // Draw all lines
        for (const auto& line : lines) {
            window.draw(line);
        }

        // Draw the current line being drawn
        window.draw(currentLine);

        // Display the contents of the window
        window.display();
    }

    return 0;
}

#include <SFML/Graphics.hpp>

#include <vector>

using namespace std;

int main() {

// Create a window

sf::RenderWindow window(sf::VideoMode(800, 600), "Simple Drawing Application");

// Vector to hold drawn lines

vector<sf::VertexArray> lines;

// Create a vertex array for the current line being drawn

sf::VertexArray currentLine(sf::LinesStrip);

bool isDrawing = false;

while (window.isOpen()) {

sf::Event event;

while (window.pollEvent(event)) {

if (event.type == sf::Event::Closed) {

window.close();

}

// Check if the mouse is pressed

if (sf::Mouse::isButtonPressed(sf::Mouse::Left)) {

if (!isDrawing) {

isDrawing = true;

currentLine.clear();

currentLine.append(sf::Vertex(sf::Vector2f(sf::Mouse::getPosition(window)), sf::Color::Red));

} else {

currentLine.append(sf::Vertex(sf::Vector2f(sf::Mouse::getPosition(window)), sf::Color::Red));

}

} else {

if (isDrawing) {

isDrawing = false;

lines.push_back(currentLine);

currentLine.clear();

}

// Clear the window

window.clear(sf::Color::White);

// Draw all lines

for (const auto& line : lines) {

window.draw(line);

}

// Draw the current line being drawn

window.draw(currentLine);

// Display the contents of the window

window.display();

}

return 0;

}

Explanation: SFML Library: The program uses the SFML library to create a graphical window and handle drawing operations. Ensure you have SFML installed and linked to your project. Window Creation: sf::RenderWindow is used to create a window with a specified size (800×600) and a title (“Simple Drawing Application”). Drawing Data: vector<sf::VertexArray> stores all the …

Drawing Application Gaming Project in C++ Read More »

Functional requirements of Course Enrollment System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements User Authentication and Authorization Allow students, instructors, and administrators to create accounts, log in, and manage their profiles. Implement role-based access control to restrict access based on user roles (e.g., students, instructors, admins). Course Catalog Management Enable administrators to create, update, and manage course offerings, including course details such as title, description, prerequisites, …

Functional requirements of Course Enrollment System with non-functional Read More »

Dijkstra’s Algorithm Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <queue>
#include <limits>

using namespace std;

const int INF = numeric_limits<int>::max(); // Represents infinity

// A structure to represent a node in the priority queue
struct Node {
    int vertex, distance;
    bool operator>(const Node& other) const {
        return distance > other.distance;
    }
};

// Function to perform Dijkstra's algorithm
vector<int> dijkstra(int start, const vector<vector<pair<int, int>>>& graph) {
    int n = graph.size();
    vector<int> distances(n, INF);
    distances[start] = 0;

    priority_queue<Node, vector<Node>, greater<Node>> pq;
    pq.push({start, 0});

    while (!pq.empty()) {
        int currentVertex = pq.top().vertex;
        int currentDistance = pq.top().distance;
        pq.pop();

        // Explore the neighbors
        for (const auto& neighbor : graph[currentVertex]) {
            int nextVertex = neighbor.first;
            int weight = neighbor.second;

            int newDistance = currentDistance + weight;

            // If a shorter path is found
            if (newDistance < distances[nextVertex]) {
                distances[nextVertex] = newDistance;
                pq.push({nextVertex, newDistance});
            }
        }
    }

    return distances;
}

int main() {
    int vertices = 6;
    vector<vector<pair<int, int>>> graph(vertices);

    // Adding edges to the graph (graph is represented as an adjacency list)
    graph[0].push_back({1, 7});
    graph[0].push_back({2, 9});
    graph[0].push_back({5, 14});
    graph[1].push_back({0, 7});
    graph[1].push_back({2, 10});
    graph[1].push_back({3, 15});
    graph[2].push_back({0, 9});
    graph[2].push_back({1, 10});
    graph[2].push_back({3, 11});
    graph[2].push_back({5, 2});
    graph[3].push_back({1, 15});
    graph[3].push_back({2, 11});
    graph[3].push_back({4, 6});
    graph[4].push_back({3, 6});
    graph[4].push_back({5, 9});
    graph[5].push_back({0, 14});
    graph[5].push_back({2, 2});
    graph[5].push_back({4, 9});

    int startVertex = 0;
    vector<int> distances = dijkstra(startVertex, graph);

    cout << "Shortest distances from vertex " << startVertex << ":\n";
    for (int i = 0; i < vertices; ++i) {
        if (distances[i] == INF) {
            cout << "Vertex " << i << ": INF (unreachable)" << endl;
        } else {
            cout << "Vertex " << i << ": " << distances[i] << endl;
        }
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <queue>

#include <limits>

using namespace std;

const int INF = numeric_limits<int>::max(); // Represents infinity

// A structure to represent a node in the priority queue

struct Node {

int vertex, distance;

bool operator>(const Node& other) const {

return distance > other.distance;

}

};

// Function to perform Dijkstra's algorithm

vector<int> dijkstra(int start, const vector<vector<pair<int, int>>>& graph) {

int n = graph.size();

vector<int> distances(n, INF);

distances[start] = 0;

priority_queue<Node, vector<Node>, greater<Node>> pq;

pq.push({start, 0});

while (!pq.empty()) {

int currentVertex = pq.top().vertex;

int currentDistance = pq.top().distance;

pq.pop();

// Explore the neighbors

for (const auto& neighbor : graph[currentVertex]) {

int nextVertex = neighbor.first;

int weight = neighbor.second;

int newDistance = currentDistance + weight;

// If a shorter path is found

if (newDistance < distances[nextVertex]) {

distances[nextVertex] = newDistance;

pq.push({nextVertex, newDistance});

}

return distances;

}

int main() {

int vertices = 6;

vector<vector<pair<int, int>>> graph(vertices);

// Adding edges to the graph (graph is represented as an adjacency list)

graph[0].push_back({1, 7});

graph[0].push_back({2, 9});

graph[0].push_back({5, 14});

graph[1].push_back({0, 7});

graph[1].push_back({2, 10});

graph[1].push_back({3, 15});

graph[2].push_back({0, 9});

graph[2].push_back({1, 10});

graph[2].push_back({3, 11});

graph[2].push_back({5, 2});

graph[3].push_back({1, 15});

graph[3].push_back({2, 11});

graph[3].push_back({4, 6});

graph[4].push_back({3, 6});

graph[4].push_back({5, 9});

graph[5].push_back({0, 14});

graph[5].push_back({2, 2});

graph[5].push_back({4, 9});

int startVertex = 0;

vector<int> distances = dijkstra(startVertex, graph);

cout << "Shortest distances from vertex " << startVertex << ":\n";

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

if (distances[i] == INF) {

cout << "Vertex " << i << ": INF (unreachable)" << endl;

} else {

cout << "Vertex " << i << ": " << distances[i] << endl;

}

return 0;

}

Explanation: Graph Representation: The graph is represented as an adjacency list using a vector of vectors. Each inner vector contains pairs representing a connected vertex and the weight of the edge to that vertex. Node Structure: The Node structure is used to store the current vertex and the distance from the source vertex. It …

Dijkstra’s Algorithm Gaming Project in C++ Read More »

Digital Signal Processing (DSP) Basics Gaming Project in C++

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

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

using namespace std;

// Function to generate a sine wave signal
vector<double> generateSineWave(double frequency, double sampleRate, int numSamples) {
    vector<double> signal(numSamples);
    double angularFrequency = 2.0 * M_PI * frequency;

    for (int i = 0; i < numSamples; ++i) {
        signal[i] = sin(angularFrequency * i / sampleRate);
    }

    return signal;
}

// Function to apply a simple low-pass filter
vector<double> lowPassFilter(const vector<double>& signal, double alpha) {
    vector<double> filteredSignal(signal.size());
    filteredSignal[0] = signal[0];

    for (size_t i = 1; i < signal.size(); ++i) {
        filteredSignal[i] = alpha * signal[i] + (1 - alpha) * filteredSignal[i - 1];
    }

    return filteredSignal;
}

// Function to print the signal
void printSignal(const vector<double>& signal) {
    for (double sample : signal) {
        cout << sample << endl;
    }
}

int main() {
    double frequency = 5.0;      // Frequency of the sine wave (Hz)
    double sampleRate = 100.0;   // Sample rate (samples per second)
    int numSamples = 100;        // Number of samples

    // Generate a sine wave
    vector<double> sineWave = generateSineWave(frequency, sampleRate, numSamples);

    // Apply a low-pass filter
    double alpha = 0.1; // Smoothing factor for the low-pass filter
    vector<double> filteredSignal = lowPassFilter(sineWave, alpha);

    // Print the original and filtered signals
    cout << "Original Sine Wave:" << endl;
    printSignal(sineWave);

    cout << "\nFiltered Signal:" << endl;
    printSignal(filteredSignal);

    return 0;
}

#include <iostream>

#include <vector>

#include <cmath>

using namespace std;

// Function to generate a sine wave signal

vector<double> generateSineWave(double frequency, double sampleRate, int numSamples) {

vector<double> signal(numSamples);

double angularFrequency = 2.0 * M_PI * frequency;

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

signal[i] = sin(angularFrequency * i / sampleRate);

}

return signal;

}

// Function to apply a simple low-pass filter

vector<double> lowPassFilter(const vector<double>& signal, double alpha) {

vector<double> filteredSignal(signal.size());

filteredSignal[0] = signal[0];

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

filteredSignal[i] = alpha * signal[i] + (1 - alpha) * filteredSignal[i - 1];

}

return filteredSignal;

}

// Function to print the signal

void printSignal(const vector<double>& signal) {

for (double sample : signal) {

cout << sample << endl;

}

int main() {

double frequency = 5.0; // Frequency of the sine wave (Hz)

double sampleRate = 100.0; // Sample rate (samples per second)

int numSamples = 100; // Number of samples

// Generate a sine wave

vector<double> sineWave = generateSineWave(frequency, sampleRate, numSamples);

// Apply a low-pass filter

double alpha = 0.1; // Smoothing factor for the low-pass filter

vector<double> filteredSignal = lowPassFilter(sineWave, alpha);

// Print the original and filtered signals

cout << "Original Sine Wave:" << endl;

printSignal(sineWave);

cout << "\nFiltered Signal:" << endl;

printSignal(filteredSignal);

return 0;

}

Explanation: Sine Wave Generation (generateSineWave): The generateSineWave function generates a sine wave signal based on a specified frequency, sample rate, and number of samples. It calculates each sample using the sine function, sin(2 * pi * frequency * i / sampleRate), where i is the sample index. The function returns a vector containing the …

Digital Signal Processing (DSP) Basics Gaming Project in C++ Read More »