Add new mini projects with READMEs: Tinder, Time Table, Graph Analyze…

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/<your-username>/3DMaze_Generator_Solver.git
+cd 3DMaze_Generator_Solver

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/<your-username>/ChessAI.git
+cd ChessAI

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/<your-username>/GraphAnalyzer.git
+cd GraphAnalyzer

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/<your-username>/Mini_Database_Engine.git
+cd Mini_Database_Engine

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/<your-username>/OSProcessSimulator.git
+cd OSProcessSimulator

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/<your-username>/Semester_Grade_Calculator.git
+cd Semester_Grade_Calculator

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/<your-username>/TimeTable_Generator.git
+cd TimeTable_Generator