Merge pull request #28 from SUJALGOYALL/feature/timetable_generator

feat(timetable): add user input, preferred slots, conflict checking, GA optimization

Author: prajwal3114

Src/Time_table_Generator/genetic_algorithm.cpp

@@ -0,0 +1,68 @@
+#include "genetic_algorithm.h"
+#include <algorithm>
+#include <cstdlib>
+#include <ctime>
+#include <iostream>
+using namespace std;
+
+Timetable GeneticAlgorithm::crossover(const Timetable& p1, const Timetable& p2) {
+    Timetable child = p1;
+    size_t half = p1.sessions.size() / 2;
+    for (size_t i = half; i < p1.sessions.size(); ++i)
+        child.sessions[i] = p2.sessions[i];
+    return child;
+}
+
+void GeneticAlgorithm::mutate(Timetable& t) {
+    if (t.rooms.empty() || t.slotsPerDay <= 0 || t.numDays <= 0) return;
+
+    for (auto &s : t.sessions) {
+        if ((rand() / (double)RAND_MAX) < mutationRate) {
+            s.day = rand() % t.numDays;
+            s.slot = rand() % t.slotsPerDay;
+            s.room = t.rooms[rand() % t.rooms.size()].name;
+        }
+    }
+}
+
+Timetable GeneticAlgorithm::run(const Timetable& base, bool verbose) {
+    if (base.rooms.empty() || base.slotsPerDay <= 0 || base.numDays <= 0) return base;
+
+    vector<Timetable> population;
+    for (int i = 0; i < populationSize; ++i) {
+        Timetable t = base;
+        t.generateRandom();
+        population.push_back(t);
+    }
+
+    Timetable best = population[0];
+    int bestFitness = best.computeConflicts();
+
+    for (int gen = 0; gen < generations; ++gen) {
+        sort(population.begin(), population.end(),
+             [](const Timetable &a, const Timetable &b){ return a.computeConflicts() < b.computeConflicts(); });
+
+        if (population[0].computeConflicts() < bestFitness) {
+            best = population[0];
+            bestFitness = best.computeConflicts();
+        }
+
+        if (bestFitness == 0) break;
+
+        vector<Timetable> newPop;
+        for (int i = 0; i < populationSize/2; ++i) {
+            Timetable c1 = crossover(population[i], population[rand() % populationSize]);
+            Timetable c2 = crossover(population[rand() % populationSize], population[i]);
+            mutate(c1);
+            mutate(c2);
+            newPop.push_back(c1);
+            newPop.push_back(c2);
+        }
+        population = newPop;
+
+        if (verbose && gen % 10 == 0)
+            cout << "Generation " << gen << " | Best Conflicts: " << bestFitness << "\n";
+    }
+
+    return best;
+}

Src/Time_table_Generator/genetic_algorithm.h

@@ -0,0 +1,22 @@
+#ifndef GENETIC_ALGORITHM_H
+#define GENETIC_ALGORITHM_H
+
+#include "timetable.h"
+
+class GeneticAlgorithm {
+public:
+    int populationSize;
+    int generations;
+    double mutationRate;
+
+    GeneticAlgorithm(int pop, int gen, double mut)
+        : populationSize(pop), generations(gen), mutationRate(mut) {}
+
+    Timetable run(const Timetable& base, bool verbose = true);
+
+private:
+    Timetable crossover(const Timetable& p1, const Timetable& p2);
+    void mutate(Timetable& t);
+};
+
+#endif

Src/Time_table_Generator/main.cpp

@@ -0,0 +1,30 @@
+#include "timetable.h"
+#include "genetic_algorithm.h"
+#include "utils.h"
+#include <iostream>
+using namespace std;
+
+int main() {
+    srand(time(nullptr));
+    cout << "\n=== C++ Timetable Generator (Genetic Algorithm) ===\n";
+
+    Timetable base = getUserInput();
+
+    int totalRequiredSessions = 0;
+    for (auto &c : base.courses) totalRequiredSessions += c.sessionsPerWeek;
+    int totalAvailableSlots = base.numDays * base.slotsPerDay * base.rooms.size();
+
+    if (totalRequiredSessions > totalAvailableSlots) {
+        cerr << "\n❌ Scheduling impossible: Total required sessions (" 
+             << totalRequiredSessions << ") exceed total available slots (" 
+             << totalAvailableSlots << ").\n";
+        cerr << "Try reducing sessions or increasing rooms/days/slots.\n";
+        return 1;
+    }
+
+    GeneticAlgorithm ga(30, 100, 0.1);
+    Timetable optimized = ga.run(base, true);
+
+    cout << "\nFinal Best Timetable (Conflicts: " << optimized.computeConflicts() << ")\n";
+    optimized.print();
+}

Src/Time_table_Generator/timetable.cpp

@@ -0,0 +1,65 @@
+#include "timetable.h"
+#include <algorithm>
+#include <iostream>
+using namespace std;
+
+void Timetable::generateRandom() {
+    if (rooms.empty() || slotsPerDay <= 0 || numDays <= 0) return;
+
+    sessions.clear();
+    srand(time(nullptr));
+    for (auto &course : courses) {
+        for (int i = 0; i < course.sessionsPerWeek; ++i) {
+            Session s;
+            s.courseName = course.name;
+            s.instructor = course.instructor;
+            s.room = rooms[rand() % rooms.size()].name;
+            s.day = rand() % numDays;
+            s.slot = rand() % slotsPerDay;
+            sessions.push_back(s);
+        }
+    }
+}
+
+int Timetable::computeConflicts() const {
+    int conflicts = 0;
+    for (size_t i = 0; i < sessions.size(); ++i) {
+        for (size_t j = i + 1; j < sessions.size(); ++j) {
+            const Session &a = sessions[i];
+            const Session &b = sessions[j];
+            if (a.day == b.day && a.slot == b.slot) {
+                if (a.room == b.room) conflicts++;
+                if (a.instructor == b.instructor) conflicts++;
+            }
+        }
+    }
+    for (auto &s : sessions) {
+        auto it = find_if(courses.begin(), courses.end(),
+                          [&](const Course &c){ return c.name == s.courseName; });
+        if (it != courses.end() && !it->allowedSlots.empty()) {
+            if (find(it->allowedSlots.begin(), it->allowedSlots.end(), s.slot) == it->allowedSlots.end())
+                conflicts++;
+        }
+    }
+    return conflicts;
+}
+
+void Timetable::print() const {
+    vector<Session> sorted = sessions;
+    sort(sorted.begin(), sorted.end(), [](const Session &a, const Session &b){
+        if (a.day != b.day) return a.day < b.day;
+        return a.slot < b.slot;
+    });
+
+    cout << "\n===== Optimized Timetable =====\n";
+    for (auto &s : sorted) {
+        string slotLabel = (s.slot >= 0 && s.slot < (int)slotLabels.size() && !slotLabels[s.slot].empty())
+                            ? slotLabels[s.slot]
+                            : ("Slot " + to_string(s.slot + 1));
+        cout << "Day " << s.day+1 << ", " << slotLabel
+             << " | " << s.courseName
+             << " | Instructor: " << s.instructor
+             << " | Room: " << s.room << "\n";
+    }
+    cout << "===============================\n";
+}

Src/Time_table_Generator/timetable.exe

@@ -0,0 +1,45 @@
+#ifndef TIMETABLE_H
+#define TIMETABLE_H
+
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Course {
+    string name;
+    string instructor;
+    int sessionsPerWeek;
+    vector<int> allowedSlots; // optional preferred slots (0-based)
+};
+
+struct Room {
+    string name;
+};
+
+struct Session {
+    string courseName;
+    string instructor;
+    string room;
+    int day;
+    int slot;
+};
+
+class Timetable {
+public:
+    int numDays;
+    int slotsPerDay;
+    vector<string> slotLabels;
+    vector<Room> rooms;
+    vector<Course> courses;
+    vector<Session> sessions;
+
+    Timetable() {}
+    Timetable(int d, int s, const vector<Room>& r, const vector<Course>& c,
+              const vector<string>& labels)
+        : numDays(d), slotsPerDay(s), rooms(r), courses(c), slotLabels(labels) {}
+
+    void generateRandom();
+    int computeConflicts() const;
+    void print() const;
+};
+
+#endif

Src/Time_table_Generator/timetable.h

@@ -0,0 +1,115 @@
+#ifndef UTILS_H
+#define UTILS_H
+
+#include "timetable.h"
+#include <regex>
+#include <iostream>
+#include <string>
+
+constexpr int MAX_DAYS = 7;
+constexpr int MAX_SLOTS = 24;
+constexpr int MAX_ROOMS = 50;
+constexpr int MAX_COURSES = 100;
+
+// Robust numeric input
+inline int getSafeInt(const std::string &prompt, int minVal, int maxVal) {
+    while (true) {
+        std::cout << prompt;
+        std::string line;
+        std::getline(std::cin, line);
+
+        line.erase(0, line.find_first_not_of(" \t\n\r"));
+        line.erase(line.find_last_not_of(" \t\n\r") + 1);
+
+        if (line.empty()) {
+            std::cout << "Input cannot be empty! Please enter a number.\n";
+            continue;
+        }
+
+        bool allDigits = true;
+        for (char c : line) {
+            if (!isdigit(c)) { allDigits = false; break; }
+        }
+        if (!allDigits) {
+            std::cout << "Invalid input! Enter a numeric integer.\n";
+            continue;
+        }
+
+        try {
+            int val = std::stoi(line);
+            if (val < minVal || val > maxVal) {
+                std::cout << "Invalid input! Enter integer between " << minVal << " and " << maxVal << ".\n";
+                continue;
+            }
+            return val;
+        } catch (...) {
+            std::cout << "Invalid input! Could not convert to number.\n";
+        }
+    }
+}
+
+// Non-empty string input
+inline std::string getNonEmptyString(const std::string &prompt) {
+    std::string s;
+    while (true) {
+        std::cout << prompt;
+        std::getline(std::cin, s);
+        if (!s.empty()) return s;
+        std::cout << "Input cannot be empty! Please enter a valid value.\n";
+    }
+}
+
+// Validate slot label (HH:MM-HH:MM or single uppercase letter)
+inline bool isValidSlotLabel(const std::string &s) {
+    std::regex timePattern(R"(\d{1,2}:\d{2}-\d{1,2}:\d{2})");
+    std::regex letterPattern(R"([A-Z])");
+    return std::regex_match(s, timePattern) || std::regex_match(s, letterPattern);
+}
+
+inline std::string getSlotLabel(int i) {
+    std::string label;
+    while (true) {
+        std::cout << "Slot " << i + 1 << " label (HH:MM-HH:MM or A-Z): ";
+        std::getline(std::cin, label);
+        if (label.empty()) label = "Slot " + std::to_string(i + 1);
+        if (isValidSlotLabel(label)) break;
+        std::cout << "Invalid format! Use HH:MM-HH:MM (09:00-10:00) or single letter (A-Z).\n";
+    }
+    return label;
+}
+
+inline Timetable getUserInput() {
+    int days = getSafeInt("Enter number of days in week (1-7): ", 1, MAX_DAYS);
+    int slots = getSafeInt("Enter slots per day (1-24): ", 1, MAX_SLOTS);
+
+    std::vector<std::string> slotLabels(slots);
+    std::cout << "\nEnter label or time for each slot:\n";
+    for (int i = 0; i < slots; ++i) slotLabels[i] = getSlotLabel(i);
+
+    int numRooms = getSafeInt("\nEnter number of rooms (1-50): ", 1, MAX_ROOMS);
+    std::vector<Room> rooms(numRooms);
+    for (int i = 0; i < numRooms; ++i) rooms[i].name = getNonEmptyString("Room " + std::to_string(i + 1) + " name: ");
+
+    int numCourses = getSafeInt("\nEnter number of courses (1-100): ", 1, MAX_COURSES);
+    std::vector<Course> courses(numCourses);
+
+    int totalAvailableSlots = days * slots * numRooms;
+
+    for (int i = 0; i < numCourses; ++i) {
+        std::cout << "\nCourse " << i + 1 << " details:\n";
+        courses[i].name = getNonEmptyString("Course name: ");
+        courses[i].instructor = getNonEmptyString("Instructor name: ");
+        courses[i].sessionsPerWeek = getSafeInt("Sessions per week: ", 1, totalAvailableSlots);
+
+        int prefCount = getSafeInt("Number of preferred slots (0 for none): ", 0, slots);
+        courses[i].allowedSlots.clear();
+        for (int j = 0; j < prefCount; ++j) {
+            int slot = getSafeInt("Preferred slot index (1-" + std::to_string(slots) + "): ", 1, slots);
+            courses[i].allowedSlots.push_back(slot - 1);
+        }
+    }
+
+    return Timetable(days, slots, rooms, courses, slotLabels);
+}
+
+#endif