fix(timetable): handle impossible schedules, validate inputs, improve conflict logic

Author: SUJALGOYALL

Src/Time_table_Generator/genetic_algorithm.cpp

@@ -1,25 +1,33 @@
 #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;
-    int half = p1.sessions.size() / 2;
+    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) {
-    int n = t.sessions.size();
-    for (int i = 0; i < n; ++i) {
+    if (t.rooms.empty() || t.slotsPerDay <= 0 || t.numDays <= 0) return;
+
+    for (auto &s : t.sessions) {
         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;
+            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;
@@ -32,25 +40,23 @@ Timetable GeneticAlgorithm::run(const Timetable& base, bool verbose) {
 
     for (int gen = 0; gen < generations; ++gen) {
         sort(population.begin(), population.end(),
-             [](const Timetable &a, const Timetable &b) {
-                 return a.computeConflicts() < b.computeConflicts();
-             });
+             [](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
+        if (bestFitness == 0) break;
 
         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);
+        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;
 

Src/Time_table_Generator/main.cpp

@@ -1,13 +1,28 @@
 #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();
 
-    GeneticAlgorithm ga(30, 100, 0.1); // pop size, generations, mutation rate
+    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";

Src/Time_table_Generator/timetable.cpp

@@ -1,69 +1,62 @@
 #include "timetable.h"
 #include <algorithm>
-#include <cstdlib>
-#include <ctime>
 #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 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);
+            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;
-
-    // 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
+                if (a.room == b.room) conflicts++;
+                if (a.instructor == b.instructor) conflicts++;
             }
         }
     }
-
-    // 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
-            }
+            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) {
+    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] 
+                            ? slotLabels[s.slot]
                             : ("Slot " + to_string(s.slot + 1));
-
-        cout << "Day " << s.day + 1 << ", " << slotLabel
+        cout << "Day " << s.day+1 << ", " << slotLabel
              << " | " << s.courseName
              << " | Instructor: " << s.instructor
              << " | Room: " << s.room << "\n";

Src/Time_table_Generator/timetable.exe

@@ -8,7 +8,7 @@ struct Course {
     string name;
     string instructor;
     int sessionsPerWeek;
-    vector<int> allowedSlots; // Optional preferred slots (0-based index)
+    vector<int> allowedSlots; // optional preferred slots (0-based)
 };
 
 struct Room {
@@ -27,7 +27,7 @@ class Timetable {
 public:
     int numDays;
     int slotsPerDay;
-    vector<string> slotLabels; // Custom time labels
+    vector<string> slotLabels;
     vector<Room> rooms;
     vector<Course> courses;
     vector<Session> sessions;

Src/Time_table_Generator/timetable.h

@@ -2,57 +2,111 @@
 #define UTILS_H
 
 #include "timetable.h"
+#include <regex>
+#include <iostream>
+#include <string>
 
-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);
+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);
+}
 
-    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;
+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;
 
-    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
+        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;
-            cout << "Preferred slot index (1-" << slots << "): ";
-            cin >> slot;
-            courses[i].allowedSlots.push_back(slot - 1); // 0-based index
+            int slot = getSafeInt("Preferred slot index (1-" + std::to_string(slots) + "): ", 1, slots);
+            courses[i].allowedSlots.push_back(slot - 1);
         }
-        cin.ignore(numeric_limits<streamsize>::max(), '\n'); // flush after the loop
-
     }
 
     return Timetable(days, slots, rooms, courses, slotLabels);