From bb4b5ee8105947d61b02d0f1a5fb34ea12fca19a Mon Sep 17 00:00:00 2001 From: PRAJAWAL G Date: Wed, 22 Oct 2025 13:50:17 +0530 Subject: [PATCH] Add new mini projects with READMEs: Tinder, Time Table, Graph Analyzer, etc. --- Src/3DMAZE_Generator&Solver/README.md | 44 ++++++++++++++ Src/Chess_Game_AI/README.md | 43 ++++++++++++++ Src/Graph_Analyzer/README.md | 57 +++++++++++++++++++ Src/Mini_Database_Engine/README.md | 48 ++++++++++++++++ .../README.md | 49 ++++++++++++++++ Src/Semester_Grade_Calculator/README.md | 50 ++++++++++++++++ Src/Time_table_Generator/README.md | 56 ++++++++++++++++++ Src/Tinder-Like/README.md | 56 ++++++++++++++++++ 8 files changed, 403 insertions(+) create mode 100644 Src/3DMAZE_Generator&Solver/README.md create mode 100644 Src/Chess_Game_AI/README.md create mode 100644 Src/Graph_Analyzer/README.md create mode 100644 Src/Mini_Database_Engine/README.md create mode 100644 Src/Operating_System_Process_simulator/README.md create mode 100644 Src/Semester_Grade_Calculator/README.md create mode 100644 Src/Time_table_Generator/README.md create mode 100644 Src/Tinder-Like/README.md diff --git a/Src/3DMAZE_Generator&Solver/README.md b/Src/3DMAZE_Generator&Solver/README.md new file mode 100644 index 0000000..de0b4b3 --- /dev/null +++ b/Src/3DMAZE_Generator&Solver/README.md @@ -0,0 +1,44 @@ +# C++ 3D Maze Generator & Solver + +## Overview +This project is a **3D Maze Generator and Solver implemented entirely in C++**. It allows users to **generate complex 3D mazes and automatically find solutions** for them. + +The system is designed using **Object-Oriented Programming (OOP)** principles, making the code **modular, maintainable, and easy to extend**. + +--- + +## Features +- Generate **3D mazes** with customizable dimensions +- Supports different **maze generation algorithms** for varied complexity +- Automatically **solves the maze** and finds the shortest path +- Displays maze structure and solution in **console-based visualization** +- Provides **step-by-step solving** for better understanding +- Implements **algorithmic techniques** for maze generation and solving + +--- + +## Requirements +- **C++ Implementation**: Entirely written in C++ +- **Object-Oriented Design**: Uses classes like `Maze`, `Cell`, `Generator`, `Solver`, etc. +- **Clean Code Practices**: + - Meaningful variable and function names + - Proper input validation and error handling + - Well-documented methods and classes + +--- + +## Functionality +- Users can define the size of the 3D maze (length, width, height) +- Maze generator creates a random solvable maze +- Solver finds the **shortest path from start to finish** +- Displays maze layout and solution clearly in the console +- Can handle large mazes efficiently using **algorithmic approaches** + +--- + +## How to Run +1. Clone the repository: + +```bash +git clone https://github.com//3DMaze_Generator_Solver.git +cd 3DMaze_Generator_Solver diff --git a/Src/Chess_Game_AI/README.md b/Src/Chess_Game_AI/README.md new file mode 100644 index 0000000..ce90fe3 --- /dev/null +++ b/Src/Chess_Game_AI/README.md @@ -0,0 +1,43 @@ +# C++ Chess Game with AI + +## Overview +This project is a **Chess Game implemented entirely in C++**. It allows users to **play chess against an AI opponent** in the console, with **all standard chess rules** enforced. + +The system is designed using **Object-Oriented Programming (OOP)** principles, making the code **modular, maintainable, and easy to extend**. + +--- + +## Features +- Play chess with all types of pieces: King, Queen, Rook, Bishop, Knight, and Pawn +- Human vs AI gameplay mode +- AI opponent uses **algorithmic decision-making** to determine optimal moves +- Console-based board display with ASCII representation +- Validates moves according to chess rules, including check, checkmate, and stalemate +- Optional: save and load game state + +--- + +## Requirements +- **C++ Implementation**: Entirely written in C++ +- **Object-Oriented Design**: Uses classes like `Board`, `Piece`, `Player`, `AI`, `Game`, etc. +- **Clean Code Practices**: + - Meaningful variable and function names + - Proper input validation and error handling + - Well-documented methods and classes + +--- + +## Gameplay +- Players input moves using **algebraic notation**, e.g., `e2 e4`. +- AI calculates moves based on **algorithmic evaluation of the board**. +- Game ends when **checkmate**, **stalemate**, or **draw** occurs. + +--- + + +## How to Run +1. Clone the repository: + +```bash +git clone https://github.com//ChessAI.git +cd ChessAI diff --git a/Src/Graph_Analyzer/README.md b/Src/Graph_Analyzer/README.md new file mode 100644 index 0000000..5939632 --- /dev/null +++ b/Src/Graph_Analyzer/README.md @@ -0,0 +1,57 @@ +# C++ Graph Analyzer + +## Overview +This project is a **Graph Analyzer implemented entirely in C++**. It allows users to **analyze a given graph and extract useful information** about its structure and properties. + +The system is designed using **Object-Oriented Programming (OOP)** principles, making the code **modular, maintainable, and easy to extend**. + +--- + +## Features +- Input a graph with vertices and edges (directed or undirected, weighted or unweighted) +- Analyze the graph to determine: + - Whether the graph contains a **cycle** + - **Minimum distance** between any two nodes + - **Connectivity** of the graph + - Degree of each vertex + - **Number of connected components** + - **Graph density** + - **Graph diameter** (longest shortest path) + - **Graph radius** (minimum eccentricity) + - **Eccentricity, centrality, and reachability** of nodes +- Console-based display of analysis results +- Implements **algorithmic techniques** for efficient graph computation + +--- + +## Requirements +- **C++ Implementation**: Entirely written in C++ +- **Object-Oriented Design**: Uses classes like `Graph`, `Vertex`, `Edge`, `Analyzer`, etc. +- **Clean Code Practices**: + - Meaningful variable and function names + - Proper input validation and error handling + - Well-documented methods and classes + +--- + +## Functionality +- Users can provide a graph via adjacency list or edge list +- Analyzer computes key properties of the graph: + - Detects **cycles** + - Calculates **shortest paths** between nodes + - Checks for **graph connectivity** + - Computes **vertex degrees, graph density, diameter, radius, and number of components** + - Determines **eccentricity, centrality, and reachability** of nodes +- Efficient algorithms ensure **quick analysis for large graphs** + +--- + + + + +## How to Run +1. Clone the repository: + +```bash +git clone https://github.com//GraphAnalyzer.git +cd GraphAnalyzer diff --git a/Src/Mini_Database_Engine/README.md b/Src/Mini_Database_Engine/README.md new file mode 100644 index 0000000..de46f90 --- /dev/null +++ b/Src/Mini_Database_Engine/README.md @@ -0,0 +1,48 @@ +# C++ Mini Database Engine + +## Overview +This project is a **Mini Database Engine implemented entirely in C++**. It allows users to **store, retrieve, and manage data efficiently** using a simplified database system. + +The system is designed using **Object-Oriented Programming (OOP)** principles, making the code **modular, maintainable, and easy to extend**. It also **supports file handling** to persist data between sessions. + +--- + +## Features +- Create, read, update, and delete (CRUD) operations on data records +- Supports multiple tables with defined schemas +- Query data using simple commands +- Ensures **data consistency and integrity** +- **File handling** to save and load database state from files +- Implements **algorithmic techniques** for indexing, searching, and organizing data efficiently + +--- + +## Requirements +- **C++ Implementation**: Entirely written in C++ +- **Object-Oriented Design**: Uses classes like `Database`, `Table`, `Record`, `QueryProcessor`, etc. +- **File Handling**: Uses file streams to persist data across sessions (`fstream`, `ifstream`, `ofstream`) +- **Clean Code Practices**: + - Meaningful variable and function names + - Proper input validation and error handling + - Well-documented methods and classes + +--- + +## Functionality +- Users can create tables with defined columns and data types +- Supports insertion, deletion, and updating of records +- Query and filter data with simple search operations +- Efficient data management using **algorithmic structures** internally +- **Save and load database** using file handling, ensuring data persists across runs +- Can handle multiple tables and multiple records per table + +--- + + + +## How to Run +1. Clone the repository: + +```bash +git clone https://github.com//Mini_Database_Engine.git +cd Mini_Database_Engine diff --git a/Src/Operating_System_Process_simulator/README.md b/Src/Operating_System_Process_simulator/README.md new file mode 100644 index 0000000..539a67e --- /dev/null +++ b/Src/Operating_System_Process_simulator/README.md @@ -0,0 +1,49 @@ +# C++ Operating System Process Simulator + +## Overview +This project is an **Operating System Process Simulator implemented entirely in C++**. It allows users to **simulate the scheduling and execution of multiple processes** as handled by an operating system. + +The system is designed using **Object-Oriented Programming (OOP)** principles, making the code **modular, maintainable, and easy to extend**. + +--- + +## Features +- Simulate multiple processes with attributes like process ID, arrival time, burst time, and priority +- Supports different **CPU scheduling algorithms**, including: + - First-Come-First-Served (FCFS) + - Shortest Job Next (SJN/SJF) + - Priority Scheduling + - Round Robin (optional) +- Displays process execution order and Gantt charts in console +- Calculates metrics such as: + - Waiting time + - Turnaround time + - Completion time +- Optional: interactive mode to add, modify, or remove processes + +--- + +## Requirements +- **C++ Implementation**: Entirely written in C++ +- **Object-Oriented Design**: Uses classes like `Process`, `Scheduler`, `OSSimulator`, etc. +- **Clean Code Practices**: + - Meaningful variable and function names + - Proper input validation and error handling + - Well-documented methods and classes + +--- + +## Simulation & Metrics +- Users can input processes with their **arrival and burst times**. +- The simulator calculates **execution order** based on the selected scheduling algorithm. +- Provides metrics such as **average waiting time, turnaround time, and CPU utilization**. +- Useful for understanding how operating systems manage process scheduling. + +--- + +## How to Run +1. Clone the repository: + +```bash +git clone https://github.com//OSProcessSimulator.git +cd OSProcessSimulator diff --git a/Src/Semester_Grade_Calculator/README.md b/Src/Semester_Grade_Calculator/README.md new file mode 100644 index 0000000..96910cd --- /dev/null +++ b/Src/Semester_Grade_Calculator/README.md @@ -0,0 +1,50 @@ +# C++ Semester Grade Calculator + +## Overview +This project is a **Semester Grade Calculator implemented entirely in C++**. It allows users to **calculate semester grades and GPA** based on marks obtained in different subjects. + +The system is designed using **Object-Oriented Programming (OOP)** principles, making the code **modular, maintainable, and easy to extend**. + +--- + +## Features +- Input marks for multiple subjects +- Calculate **percentage, grade, and GPA** automatically +- Supports **different grading scales** (e.g., A-F, 4.0 GPA, 10-point scale) +- Console-based display of results +- Validates input to ensure **marks are within acceptable ranges** +- Can generate **summary of all subjects** with grades and GPA +- Implements **algorithmic calculations** for grades and GPA + +--- + +## Requirements +- **C++ Implementation**: Entirely written in C++ +- **Object-Oriented Design**: Uses classes like `Semester`, `Subject`, `Calculator`, etc. +- **Clean Code Practices**: + - Meaningful variable and function names + - Proper input validation and error handling + - Well-documented methods and classes + +--- + +## Functionality +- Users can enter: + - Number of subjects + - Marks obtained in each subject + - Credit hours for each subject (optional) +- The program computes: + - Percentage for each subject + - Grade based on chosen grading scale + - Semester GPA based on credits and grades +- Ensures calculations are **accurate and consistent** across all inputs + +--- + + +## How to Run +1. Clone the repository: + +```bash +git clone https://github.com//Semester_Grade_Calculator.git +cd Semester_Grade_Calculator diff --git a/Src/Time_table_Generator/README.md b/Src/Time_table_Generator/README.md new file mode 100644 index 0000000..080e4d8 --- /dev/null +++ b/Src/Time_table_Generator/README.md @@ -0,0 +1,56 @@ +# C++ Time Table Generator + +> **Note:** This project **must use a Genetic Algorithm in C++** to generate optimized timetables. +> Your implementation **should be able to handle all edge cases**, including multiple conflicting constraints, limited rooms or time slots, and overlapping instructor schedules. +> Only submissions that meet these criteria will be considered for PR acceptance. + +## Overview +This project is a **Time Table Generator implemented entirely in C++**. It allows users to **automatically generate optimized timetables** for classes, labs, or events while avoiding conflicts. + +The system is designed using **Object-Oriented Programming (OOP)** principles, making the code **modular, maintainable, and easy to extend**. + +--- + +## Features +- Generate conflict-free timetables for multiple classes, instructors, and rooms +- Handles constraints such as: + - Avoiding overlapping classes for the same instructor + - Avoiding room conflicts + - Specific time-slot preferences +- Implements a **Genetic Algorithm** to optimize the timetable +- Console-based display of generated timetables +- Ensures the solution **covers all edge cases**, making it robust for real-world scenarios + +--- + +## Requirements +- **C++ Implementation**: Entirely written in C++ +- **Object-Oriented Design**: Uses classes like `TimeTable`, `Class`, `Instructor`, `Room`, `GeneticAlgorithm`, etc. +- **Genetic Algorithm**: Required for optimization +- **Clean Code Practices**: + - Meaningful variable and function names + - Proper input validation and error handling + - Well-documented methods and classes + +--- + +## Functionality +- Users can input: + - Number of classes and instructors + - Available rooms + - Time slots and constraints +- The program **generates optimized timetables** satisfying all constraints +- Ensures **no conflicts** for instructors, rooms, or overlapping sessions +- Uses **algorithmic techniques (Genetic Algorithm)** to find the best solution efficiently +- Designed to **handle edge cases**, such as multiple conflicting constraints or limited resources + +--- + + + +## How to Run +1. Clone the repository: + +```bash +git clone https://github.com//TimeTable_Generator.git +cd TimeTable_Generator diff --git a/Src/Tinder-Like/README.md b/Src/Tinder-Like/README.md new file mode 100644 index 0000000..ee58f75 --- /dev/null +++ b/Src/Tinder-Like/README.md @@ -0,0 +1,56 @@ +# C++ Tinder-Like App + +## Overview +This project is a **Tinder-like dating app simulation implemented entirely in C++**. It allows users to **create profiles, swipe on other profiles, and match with compatible users**. + +The system is designed using **Object-Oriented Programming (OOP)** principles, making the code **modular, maintainable, and easy to extend**. + +> **File Handling:** The app uses file streams to **save and load profiles, matches, and chat history**, ensuring data persists between sessions. + +--- + +## Features +- Create user profiles with attributes such as name, age, gender, interests, and location +- Swipe functionality to **like or pass on profiles** +- **Match users** based on mutual interest and compatibility +- Store and display **matches and chat history** +- Console-based interface for simplicity +- Implements **algorithmic matching logic** to suggest potential matches efficiently +- Input validation to ensure consistent profile information +- **File handling** to persist user data and matches across sessions + +--- + +## Requirements +- **C++ Implementation**: Entirely written in C++ +- **Object-Oriented Design**: Uses classes like `User`, `Profile`, `MatchEngine`, `Chat`, etc. +- **File Handling**: Uses `fstream` to read and write profile, match, and chat data +- **Clean Code Practices**: + - Meaningful variable and function names + - Proper input validation and error handling + - Well-documented methods and classes + +--- + +## Functionality +- Users can: + - Create or edit their profile + - Browse other profiles + - Swipe left (pass) or swipe right (like) + - See matched users and chat with them +- Matching logic: + - Uses **algorithmic evaluation** of profile compatibility + - Suggests potential matches based on mutual likes and shared interests +- **Data persists** between sessions through file handling +- Console interface displays **profile details, matches, and interactions** + +--- + + + +## How to Run +1. Clone the repository: + +```bash +git clone https://github.com//Tinder_Like_App.git +cd Tinder_Like_App