fill students schedules

include/generator.h

@@ -7,15 +7,13 @@
 #ifndef GENERATOR_H_INCLUDED
 #define GENERATOR_H_INCLUDED
 
-const char FLEX[2][11] = {"XAT--12A-S", "XAT--12B-S"};
-
 typedef struct {
   uint8_t numberOfClasses;
-  char classes[CLASSROOMS][MAX_COURSE_ID_LEN];
+  CLASS classes[CLASSROOMS];
 } TIMETABLE_BLOCK;
 
 typedef struct {
-  TIMETABLE_BLOCK timetable[TOTAL_BLOCKS];
+  TIMETABLE_BLOCK blocks[TOTAL_BLOCKS];
   bool success;
 } TIMETABLE;
 

include/main.h

@@ -31,4 +31,6 @@
 // 5 is the length of "FALSE" & 3 is the number of commas per line
 #define MAX_CHAR MAX_PUPIL_NUM_LEN + MAX_COURSE_NO_LEN + MAX_COURSE_DES_LEN + 5 + 3
 
+static const char FLEX[][11] = {"XAT--12A-S", "XAT--12B-S"};
+
 #endif

include/students.h

@@ -16,7 +16,7 @@ typedef struct {
   uint32_t pupilNum;
   REQUEST *requests;
   uint8_t requestsLen;
-  char **schedule;
+  char schedule[TOTAL_BLOCKS][MAX_COURSE_ID_LEN];
   uint8_t expectedClasses;
   uint8_t classes;
   REQUEST *remainingAlts;

src/generator.c

@@ -57,7 +57,8 @@ int stepIndex(int offset, StepType type, uint8_t blocksPerSemester) {
 }
 
 TIMETABLE generateTimetable(STUDENT *students, size_t size_students, COURSE *courses, size_t size_courses) {
-  TIMETABLE_BLOCK defaultBlock = {0, {"\0"}};
+  TIMETABLE_BLOCK defaultBlock;
+  defaultBlock.numberOfClasses = 0;
   TIMETABLE timetable = {{defaultBlock}, false};
 
   uint8_t MEDIAN = floor((float) (MIN_REQ + CLASS_CAP) / 2);
@@ -306,6 +307,7 @@ TIMETABLE generateTimetable(STUDENT *students, size_t size_students, COURSE *cou
             // Class exists with room for student
             if (currentInserted[j] < classes[j].numberOfStudents) {
               classes[j].students[currentInserted[j]] = student.pupilNum;
+              student.classes++;
               currentInserted[j]++;
               getAvailableCourse = false;
               break;
@@ -364,12 +366,14 @@ TIMETABLE generateTimetable(STUDENT *students, size_t size_students, COURSE *cou
       }
     }
 
-    // Asign remaining alternates to student
+    // Asign remaining alternates && classes to student
     for (size_t i = 0; i < size_students; i++) {
       if (students[i].pupilNum == student.pupilNum) {
         students[i].remainingAlts = realloc(students[i].remainingAlts, numberOfAlts * sizeof(REQUEST));
         memcpy(students[i].remainingAlts, alternates, numberOfAlts * sizeof(REQUEST));
         students[i].remainingAltsLen = numberOfAlts;
+
+        students[i].classes = student.classes;
         break;
       }
     }
@@ -410,7 +414,7 @@ TIMETABLE generateTimetable(STUDENT *students, size_t size_students, COURSE *cou
     // Tally first semester and second semester
     uint8_t allSemesterBlockLens[TOTAL_BLOCKS] = {0};
     for (uint8_t i = 0; i < TOTAL_BLOCKS; i++)
-       allSemesterBlockLens[i] = timetable.timetable[i].numberOfClasses;
+       allSemesterBlockLens[i] = timetable.blocks[i].numberOfClasses;
 
     // If there is more than one class running
     if (allClassRunCounts[index] > 1) {
@@ -439,19 +443,15 @@ TIMETABLE generateTimetable(STUDENT *students, size_t size_students, COURSE *cou
       }
       uint8_t classRunCounts = allClassRunCounts[index];
       for (size_t i = 0; i < classRunCounts; i++) {
-        // Get class ID
-        char className[MAX_COURSE_ID_LEN] = {"\0"};
-        strcpy(className, classes[baseIndex + indexOffset].crsNo);
-
         bool classInserted = false;
         while (!classInserted) {
           blockIndex += offset;
           
           // Insert class          
-          if (timetable.timetable[blockIndex].numberOfClasses < CLASSROOMS) {
+          if (timetable.blocks[blockIndex].numberOfClasses < CLASSROOMS) {
-            uint8_t classIndex = timetable.timetable[blockIndex].numberOfClasses;
+            uint8_t classIndex = timetable.blocks[blockIndex].numberOfClasses;
-            strcpy(timetable.timetable[blockIndex].classes[classIndex], className);
+            timetable.blocks[blockIndex].classes[classIndex] = classes[baseIndex + indexOffset];
-            timetable.timetable[blockIndex].numberOfClasses++;
+            timetable.blocks[blockIndex].numberOfClasses++;
             allClassRunCounts[index]--;
             indexOffset++;
             classInserted = true;
@@ -479,7 +479,6 @@ TIMETABLE generateTimetable(STUDENT *students, size_t size_students, COURSE *cou
       }
 
       // Get class ID index
-      char className[MAX_COURSE_ID_LEN] = {"\0"};
       size_t baseIndex = 0;
       for (size_t i = 0; i < classesLen; i++) {
         if (strcmp(classes[i].baseCrsNo, activeCourses[index]) == 0) {
@@ -489,10 +488,9 @@ TIMETABLE generateTimetable(STUDENT *students, size_t size_students, COURSE *cou
       }
 
       // Insert class
-      strcpy(className, classes[baseIndex].crsNo);
+      uint8_t classIndex = timetable.blocks[blockIndex].numberOfClasses;
-      uint8_t classIndex = timetable.timetable[blockIndex].numberOfClasses;
+      timetable.blocks[blockIndex].classes[classIndex] = classes[baseIndex];
-      strcpy(timetable.timetable[blockIndex].classes[classIndex], className);
+      timetable.blocks[blockIndex].numberOfClasses++;
-      timetable.timetable[blockIndex].numberOfClasses++;
       allClassRunCounts[index]--;
     }
 
@@ -527,7 +525,19 @@ TIMETABLE generateTimetable(STUDENT *students, size_t size_students, COURSE *cou
   }
 
 
-  // STEP 5 - something
+  // STEP 5 - fill student schedule
+  for (size_t i = 0; i < TOTAL_BLOCKS; i++) {
+    for (size_t j = 0; j < timetable.blocks[i].numberOfClasses; j++) {
+      for (size_t k = 0; k < timetable.blocks[i].classes[j].numberOfStudents; k++) {
+        for (size_t l = 0; l < size_students; l++) {
+          if (students[l].pupilNum == timetable.blocks[i].classes[j].students[k]) {
+            strcpy(students[l].schedule[i], timetable.blocks[i].classes[j].crsNo);
+            break;
+          }
+        }
+      }
+    }
+  }
 
 
   // STEP 6 - most complex something

src/json.c

@@ -51,15 +51,11 @@ int writeStudentsToJson(STUDENT *students, size_t numberOfStudents, char output_
     fprintf(stream, "    ],\n");
     fprintf(stream, "    \"requestsLen\": %d,\n", students[i].requestsLen);
     
-    if (students[i].classes > 0) {
+    fprintf(stream, "    \"schedule\": [\n");
-      fprintf(stream, "    \"schedule\": [\n");
+    for (size_t j = 0; j < TOTAL_BLOCKS; j++) {
-      for (size_t j = 0; j < students[i].classes; j++) {
+      fprintf(stream, "      \"%s\"%s\n", students[i].schedule[j], j == TOTAL_BLOCKS - 1 ? "" : ",");
-        fprintf(stream, "      \"%s\"%s\n", students[i].schedule[j], j == students[i].classes - 1 ? "" : ",");
-      }
-      fprintf(stream, "    ],\n");
-    } else {
-      fprintf(stream, "    \"schedule\": [],\n");
     }
+    fprintf(stream, "    ],\n");
   
     fprintf(stream, "    \"expectedClasses\": %d,\n", students[i].expectedClasses);
     fprintf(stream, "    \"classes\": %d,\n", students[i].classes);

src/main.c

@@ -52,7 +52,6 @@ int main(int argc, char **argv) {
 
   for (size_t i = 0; i < students_info.numberOfStudents; i++) {
     free(students[i].requests);
-    free(students[i].schedule);
     free(students[i].remainingAlts);
   }
   free(students);

src/students.c

@@ -53,8 +53,8 @@ STUDENT *getStudents(CSV_LINE *lines, size_t lines_len, int total_blocks, UNIQUE
     REQUEST *requests = malloc(numRequests[i] * sizeof(REQUEST));
     student.requests = requests;
 
-    char **schedule = malloc(TOTAL_BLOCKS * sizeof(int*));
+    for (uint8_t i = 0; i < TOTAL_BLOCKS; i++)
-    student.schedule = schedule;
+      strcpy(student.schedule[i], i < TOTAL_BLOCKS / 2 ? FLEX[0] : FLEX[1]);
 
     REQUEST *remainingAlts = malloc(MAX_REQUEST_ALTS * sizeof(REQUEST));
     student.remainingAlts = remainingAlts;