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

Author: SUJALGOYALL

Src/Time_table_Generator/genetic_algorithm.cpp

@@ -0,0 +1,62 @@
+#include "genetic_algorithm.h"
+
+Timetable GeneticAlgorithm::crossover(const Timetable& p1, const Timetable& p2) {
+    Timetable child = p1;
+    int 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) {
+    int n = t.sessions.size();
+    for (int i = 0; i < n; ++i) {
+        if ((rand() / (double)RAND_MAX) < mutationRate) {
+            t.sessions[i].day = rand() % t.numDays;
+            t.sessions[i].slot = rand() % t.slotsPerDay;
+            t.sessions[i].room = t.rooms[rand() % t.rooms.size()].name;
+        }
+    }
+}
+
+Timetable GeneticAlgorithm::run(const Timetable& base, bool verbose) {
+    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; // Perfect timetable found
+
+        vector<Timetable> newPop;
+        for (int i = 0; i < populationSize / 2; ++i) {
+            Timetable child1 = crossover(population[i], population[rand() % populationSize]);
+            Timetable child2 = crossover(population[rand() % populationSize], population[i]);
+            mutate(child1);
+            mutate(child2);
+            newPop.push_back(child1);
+            newPop.push_back(child2);
+        }
+        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,15 @@
+#include "timetable.h"
+#include "genetic_algorithm.h"
+#include "utils.h"
+
+int main() {
+    srand(time(nullptr));
+    cout << "\n=== C++ Timetable Generator (Genetic Algorithm) ===\n";
+    Timetable base = getUserInput();
+
+    GeneticAlgorithm ga(30, 100, 0.1); // pop size, generations, mutation rate
+    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,72 @@
+#include "timetable.h"
+#include <algorithm>
+#include <cstdlib>
+#include <ctime>
+#include <iostream>
+using namespace std;
+
+void Timetable::generateRandom() {
+    sessions.clear();
+    srand(time(nullptr));
+    for (auto &course : courses) {
+        for (int i = 0; i < course.sessionsPerWeek; ++i) {
+            Session session;
+            session.courseName = course.name;
+            session.instructor = course.instructor;
+            session.room = rooms[rand() % rooms.size()].name;
+            session.day = rand() % numDays;
+            session.slot = rand() % slotsPerDay;
+            sessions.push_back(session);
+        }
+    }
+}
+
+int Timetable::computeConflicts() const {
+    int conflicts = 0;
+
+    // Room & instructor conflicts
+    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++;            // Room conflict
+                if (a.instructor == b.instructor) conflicts++; // Instructor conflict
+            }
+        }
+    }
+
+    // Preferred time-slot 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++; // Penalize for being outside preferred slots
+            }
+        }
+    }
+
+    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 index)
+};
+
+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; // Custom time labels
+    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,61 @@
+#ifndef UTILS_H
+#define UTILS_H
+
+#include "timetable.h"
+
+Timetable getUserInput() {
+    int days, slots, numRooms, numCourses;
+    cout << "Enter number of days in week: ";
+    cin >> days;
+    cout << "Enter slots per day: ";
+    cin >> slots;
+
+    cout << "\nEnter a label or time for each slot (e.g., 9:00-10:00):\n";
+    vector<string> slotLabels(slots);
+    cin.ignore(numeric_limits<streamsize>::max(), '\n'); // flush buffer
+    for (int i = 0; i < slots; ++i) {
+        cout << "Slot " << i + 1 << " label: ";
+        getline(cin, slotLabels[i]);
+        if (slotLabels[i].empty()) slotLabels[i] = "Slot " + to_string(i + 1);
+    }
+
+    cout << "\nEnter number of rooms: ";
+    cin >> numRooms;
+    vector<Room> rooms(numRooms);
+    for (int i = 0; i < numRooms; ++i) {
+        cout << "Room " << i + 1 << " name: ";
+        cin >> rooms[i].name;
+    }
+
+    cout << "\nEnter number of courses: ";
+    cin >> numCourses;
+    vector<Course> courses(numCourses);
+    for (int i = 0; i < numCourses; ++i) {
+        cout << "\nCourse " << i + 1 << " name: ";
+        cin >> courses[i].name;
+        cout << "Instructor name: ";
+        cin >> courses[i].instructor;
+        cout << "Sessions per week: ";
+        cin >> courses[i].sessionsPerWeek;
+
+        // Preferred slots
+        cout << "Enter number of preferred slots for this course (0 for no preference): ";
+        int prefCount;
+        cin >> prefCount;
+        cin.ignore(numeric_limits<streamsize>::max(), '\n'); // flush leftover newline
+
+        courses[i].allowedSlots.clear();
+        for (int j = 0; j < prefCount; ++j) {
+            int slot;
+            cout << "Preferred slot index (1-" << slots << "): ";
+            cin >> slot;
+            courses[i].allowedSlots.push_back(slot - 1); // 0-based index
+        }
+        cin.ignore(numeric_limits<streamsize>::max(), '\n'); // flush after the loop
+
+    }
+
+    return Timetable(days, slots, rooms, courses, slotLabels);
+}
+
+#endif