colloscope/algorithm.c

/*
 *   Colloscope - A program that generates a colloscope for French 'classes prépas'
 *  Copyright (C) 2024  Alexandre Aboujaib
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */


#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#include "logger.h"
#include "structure.h"
#include "algorithm.h"

bool is_equal_date(date d1, date d2) {
    return (d1.hour == d2.hour && d1.day == d2.day && d2.month == d1.month && d2.year == d1.year);
}

int get_date_index(creneau* edt, int len_creneau, date d) {
    // could be done in log(n), I know
    // yields the 1st occurence of d in edt
    int x = -1;
    for(int i = 0; i < len_creneau; i++) {
        x = date_dist(d, edt[i].date);
        if(x >= 0) {
            return i;
        }
    } 
    return -1;
}

int get_next_friday(creneau* edt, int len_creneau, date d) {
    // could be done in log(n), I know again
    int x = -1;
    for(int i = 0; i < len_creneau; i++) {
        x = date_dist(d, edt[i].date);
        if(x >= 0 && (i == len_creneau-1 || date_dist(d, edt[i+1].date) - x > 1)) {
            return i;
        }
    } 
    return -1;
}

// typedef struct colleur {char* name; int namelen; topic mat; date* disp; int n_disp;} colleur;
colleur* get_colleurs(colleur* cl, int len_cl, date d, int* how_many) {
    colleur* res = malloc(sizeof(colleur)*30); // max. 3 colles per creneau
    int ptr = 0;
    for(int i = 0; i < len_cl; i++) {
        for(int j = 0; j < cl[i].n_disp; j++) {
            if(is_equal_date(cl[i].disp[j], d)) {
                if(ptr >= 30) {
                    warn("Too many colleurs detected for a creneau\n");
                }
                res[ptr] = cl[i];
                ptr++;
                j = cl[i].n_disp;
            }
        }
    }
    *how_many = ptr;
    return res;
}

void swap(int* arr, int i, int j) {
    if(i != j) {
        arr[i] += arr[j];
        arr[j] = arr[i] - arr[j];
        arr[i] -= arr[j];
    }
}

void generate_random_perm(int* arr, int len) {
    // generate a random perm of int between 0 and len-1
    for(int i = 0; i < len; i++) {
        arr[i] = i;
    }
    for(int i = 0; i < len; i++) {
        swap(arr, i, rand()%len);
    }
}

void print_arr(int* arr, int len) {
    printf("[");
    for(int i = 0; i < len; i++) {
        printf("%d ", arr[i]);
    }
    printf("]\n");
}

void add_colle(creneau* edt, colleur* chads, int grp, int id_edt, int id_chad) {
    edt[id_edt].group = grp;
    edt[id_edt].namelen = chads[id_chad].namelen;
    str_copy(chads[id_chad].name, chads[id_chad].namelen, edt[id_edt].name);
    edt[id_edt].mat = chads[id_chad].mat;
}

void remove_colle(creneau* edt, int id_edt) {
    edt[id_edt].group = 0;
    edt[id_edt].namelen = 0;
    str_copy("none", 4, edt[id_edt].name);
    edt[id_edt].mat = NOTHING;
}

void move_colle(creneau* edt, int len_edt, int id_src, int id_dest) {
    if((id_src < len_edt && id_src >= 0 && id_dest < len_edt && id_dest >= 0) == false) {
        printf("Bad\n");
        exit(1);
    }
    
    edt[id_dest].group = edt[id_src].group;
    edt[id_dest].namelen = edt[id_src].namelen;
    str_copy(edt[id_src].name, edt[id_src].namelen, edt[id_dest].name);
    edt[id_dest].mat = edt[id_src].mat;

    remove_colle(edt, id_src);
}

int mem_id(creneau* edt, int len_edt, int grp, char* colleur, int offset) {
    for(int i = offset; i < len_edt; i++) {
        if(edt[i].group == grp && str_equal(edt[i].name, colleur)) {
            return i;
        }
    }
    return -1;
}

bool is_overlap(creneau* edt, int len_edt, int id) {    // detect if a colleur has 2 colles at the same time
    int k = 1;
    while(id+k < len_edt && is_equal_date(edt[id].date, edt[id+k].date)) {
        if(str_equal(edt[id].name, edt[id+k].name)) {
            return true;
        }
        k++;
    }
    k = 1;
    while(id-k >= 0 && is_equal_date(edt[id].date, edt[id-k].date)) {
        if(str_equal(edt[id].name, edt[id-k].name)) {
            return true;
        }
        k++;
    }
    return false;
}

bool is_overlap_creneau(creneau* edt, int len_edt, int id, int grp) { // detect if a group has 2 overlapping colles
    int k = 1;
    while((id+k < len_edt && edt[id+k].date.hour - edt[id].date.hour < edt[id].length) && edt[id+k].date.day == edt[id].date.day) {
        if(edt[id+k].group == grp) {
            return true;
        }
        k++;
    }
    k = 1;
    while(id-k >= 0 && is_equal_date(edt[id].date, edt[id-k].date)) {
        if(edt[id+k].group == grp) {
            return true;
        }
        k++;
    }
    return false;
}

int free_math_space(creneau* edt, int len_edt, int id) {
    int k = 1;
    int howmany = 0;
    while(id+k < len_edt && is_equal_date(edt[id].date, edt[id+k].date)) {
        if(edt[id+k].mat == NOTHING || edt[id+k].mat == MATH) {
            howmany++;
        }
        k++;
    }
    k = 1;
    while(id-k >= 0 && is_equal_date(edt[id].date, edt[id-k].date)) {
        if(edt[id-k].mat == NOTHING || edt[id-k].mat == MATH) {
            howmany++;
        }
        k++;
    }
    return howmany;
}

void add_colles_for_group_MP2I(int* weeks_len, creneau* edt, int len_edt, colleur* chads, int len_chads, int n_weeks, int grp, topic start_rotation, int mth, int inf, int* skip_count, int mat_halt, int info_app) {
    topic rotation = start_rotation;    // physics/english rotation
    int math = mth;                     // math (3/4)
    int info = inf;                     // info (1/6)

    int r;              // randomize the 1st date
    int k = 0;          // offset
    int halt = 0;       // timeout in case a colle cannot be placed
    bool found;         // interrupt in case a valid colle has been found

    int remaining_to_add = 0;  /* self-explainatory
    please note that this also tells what colle to add :
    1 = physics/english colle
    2 = math
    3 (not implemented) = info
    */
    int len_dudes = 0;                              // length of colleur*

    int len_perm = 0;                       // length of int*

    int math_dude = 0;                              // length of colleur*
    int weeklen;

    bool normal_skip = true;

    for(int week = 0; week < n_weeks; week++) {
    
        weeklen = weeks_len[week];
        // update what colles to add
        if(mat_halt == 1 || math == 0) {
            math = mat_halt-1;
        } else {
            remaining_to_add++;
            math--;
        }
        if(rotation == ENGLISH) {
            rotation = PHYSICS;
        } else {
            rotation = ENGLISH;
        }

        remaining_to_add++; // physics/english

        // initialize/reset variables
        r = rand()%weeklen;
        halt = 0;
        found = false;
        normal_skip = true;

        info++;
        // info colle
        while(info >= info_app) {
            if(edt[k+r%weeklen].mat == NOTHING && edt[k+r%weeklen].length == 2) {   
                // if creneau is empty
                // import all colleurs available
                colleur* dudes = get_colleurs(chads, len_chads, edt[k+r%weeklen].date, &len_dudes);
                len_perm = len_dudes;

                // if there are colleurs available
                if(len_dudes != 0) {

                    // randomize the order of colleurs
                    int* perm = malloc(sizeof(int)*len_perm);
                    generate_random_perm(perm, len_perm);

                    // for each one of them, add his colle for selected group pf and only if
                    // - he is a INFO colleur
                    // if a colle has been addded, interrupt the for andwhile loops
                    for(int dude = 0; dude < len_perm*(1-found); dude++) {
                        if(dudes[perm[dude]].mat == INFO && edt[k+r%weeklen].allow_grps[grp-1] == true) {
                            add_colle(edt, dudes, grp, k+r%weeklen, perm[dude]);
                            found = true;
                            info = 0;
                        } else if(edt[k+r%weeklen].allow_grps[grp-1] == true) {
                            normal_skip = false;
                        }
                    }
                    free(perm);
                }
                free(dudes);
            }
            if(!found && halt > weeklen) {
                info = 0;
                *skip_count += (1-normal_skip);
            }
            r++;
            halt++;
        }
        // reset the variables
        r = rand()%weeklen;
        found = false;
        halt = 0;
        normal_skip = true;

        // if there is a math colle to add, enter this loop
        while(remaining_to_add == 2) {

            if(edt[k+r%weeklen].mat == NOTHING && edt[k+r%weeklen].length == 1) {   
                // if creneau is empty
                // import all colleurs available
                colleur* dudes = get_colleurs(chads, len_chads, edt[k+r%weeklen].date, &len_dudes);
                len_perm = len_dudes;

                // if there are colleurs available
                if(len_dudes != 0) {

                    // randomize the order of colleurs
                    int* perm = malloc(sizeof(int)*len_perm);
                    generate_random_perm(perm, len_perm);

                    // for each one of them, add his colle for selected group pf and only if
                    // - he is a MATH colleur
                    // - he does not have another colle at the same time (is_overlap)
                    // if a colle has been addded, interrupt the for andwhile loops
                    for(int dude = 0; dude < len_perm*(1-found); dude++) {
                        if(dudes[perm[dude]].mat == MATH && edt[k+r%weeklen].allow_grps[grp-1] == true) {
                            add_colle(edt, dudes, grp, k+r%weeklen, perm[dude]);
                            if(is_overlap(edt, len_edt, k+r%weeklen)) {
                                remove_colle(edt, k+r%weeklen);
                            } else {
                                found = true;
                                remaining_to_add--;
                            }
                        }
                    }
                    free(perm);
                }
                free(dudes);
            }
            if(!found && halt > weeklen) {
                remaining_to_add--;
                *skip_count += 1;
            }
            r++;
            halt++;
        }
        // reset the variables
        r = rand()%weeklen;
        found = false;
        halt = 0;

        // do it again for physics/english colles
        while(remaining_to_add == 1) {
            if(edt[k+r%weeklen].mat == NOTHING && edt[k+r%weeklen].length == 1) {
                colleur* dudes = get_colleurs(chads, len_chads, edt[k+r%weeklen].date, &len_dudes);
                len_perm = len_dudes;
                if(len_dudes != 0) {
                    int* perm = malloc(sizeof(int)*len_perm);
                    generate_random_perm(perm, len_perm);
                    math_dude = 0;
                    for(int dude = 0; dude < len_dudes; dude++) {
                        if(dudes[dude].mat == MATH) {
                            math_dude++;
                        }
                    }
                    for(int dude = 0; dude < len_perm*(1-found); dude++) {
                        if(dudes[perm[dude]].mat == rotation && edt[k+r%weeklen].allow_grps[grp-1] == true) {
                            add_colle(edt, dudes, grp, k+r%weeklen, perm[dude]);
                            if(math_dude > free_math_space(edt, len_edt, k+r%weeklen) || is_overlap(edt, len_edt, k+r%weeklen)) {
                                remove_colle(edt, k+r%weeklen);
                            } else {
                                found = true;
                                remaining_to_add--;
                            }
                        }
                    }
                    free(perm);
                }
                free(dudes);
            }
            if(!found && halt > weeks_len[week]) {
                remaining_to_add--;
                *skip_count += 1;
            }
            r++;
            halt++;
        }

        k += weeks_len[week];
        remaining_to_add = 0;
    }
}

void write_to_file(char* filename, creneau* edt, int len_edt) {
    FILE* ptr = fopen(filename, "w");
    fprintf(ptr, "hour,day,month,year,length,group,colleur,matiere\n");
    for(int i = 0; i < len_edt; i++) {
        fprintf(ptr, "%d,%d,%d,%d,%d,%d,%s,", edt[i].date.hour, edt[i].date.day, edt[i].date.month, edt[i].date.year, edt[i].length, edt[i].group, edt[i].name);
        if(edt[i].mat == NOTHING) {
            fprintf(ptr, "_");
        } else if(edt[i].mat == MATH) {
            fprintf(ptr, "Maths");
        } else if(edt[i].mat == PHYSICS) {
            fprintf(ptr, "Physique");
        } else if(edt[i].mat == ENGLISH) {
            fprintf(ptr, "Anglais");
        } else if(edt[i].mat == INFO) {
            fprintf(ptr, "Info");
        } else if(edt[i].mat == FRENCH) {
            fprintf(ptr, "Français");
        } else {
            fprintf(ptr, "Unknown");
        }
        fprintf(ptr, "\n");
    }
    fclose(ptr);
}

int min(int x, int y) {
    if(x < y) {
        return x;
    }
    return y;
}

int max(int x, int y) {
    if(x > y) {
        return x;
    }
    return y;
}

int score(creneau* edt, int len_edt, int grp, int n_weeks) {
    int score = 100;
    
    int dist = 0;
    for(int i = 0; i < len_edt; i++) {
        for(int j = i+1; j < len_edt; j++) {
            if(edt[i].group == grp && edt[j].group == grp) {
                dist = date_dist(edt[i].date, edt[j].date);
                if(dist == 0) {
                    score -= 4;
                }
                /*if(str_equal(edt[i].name, edt[j].name)) {
                    score -= max(0, 28-dist);
                }*/
                if(dist == 7 && edt[i].date.hour == edt[j].date.hour) {
                    score -= 5;
                }
                if(dist < 5 && edt[i].date.hour == 18 && edt[j].date.hour == 18) {
                    score -= 5;
                }
            }
        }
    }

    char** met = malloc(sizeof(char*)*3*n_weeks);
    int p = 0;
    for(int i = 0; i < len_edt; i++) {
        if(edt[i].group == grp) {
            met[p] = malloc(sizeof(char)*30);
            str_copy(edt[i].name, edt[i].namelen, met[p]);
            for(int k = p-1; k >= 0; k--) {
                if(str_equal(met[k], met[p])) {
                    switch(edt[i].mat) {
                        case MATH:
                            score -= 12;
                            break;
                        case PHYSICS:
                            score -= 12;
                            break;
                        case ENGLISH:
                            score -= 12;
                            break;
                        default:
                            break;
                    }
                }
            }
            p++;
        }
    }

    for(int f = 0; f < p; f++) {
        free(met[f]);
    }
    free(met);
    return score;
}

int get_colleur_id(colleur* dudes, int n_dudes, char* target) {
    for(int i = 0; i < n_dudes; i++) {
        if(str_equal(dudes[i].name, target)) {
            return i;
        }
    }
    return -1;
}

char* get_name_from_id(colleur* dudes, int n_dudes, int id) {
    for(int i = 0; i < n_dudes; i++) {
        if(id == dudes[i].id) {
            return dudes[i].name;
        }
    }
    return "none";
}

topic get_mat_from_id(colleur* dudes, int n_dudes, int id) {
    for(int i = 0; i < n_dudes; i++) {
        if(id == dudes[i].id) {
            return dudes[i].mat;
        }
    }
    return NOTHING;
}

int** generate_matrix(int lines, int columns, int def) {
    int** mat = malloc(sizeof(int*)*lines);
    for(int i = 0; i < lines; i++) {
        mat[i] = malloc(sizeof(int)*columns);
        for(int j = 0; j < columns; j++) {
            mat[i][j] = def;
        }
    }
    return mat;
}

void destroy_matrix(int** m, int li) {
    for(int i = 0; i < li; i++) {
        free(m[i]);
    }
    free(m);
}

bool retreive_indexes(creneau* edt, int len_edt, int* p1, int* p2, int g1, int g2, char* n1, char* n2, int n_weeks) {
    int* indexes_1 = malloc(sizeof(int)*n_weeks);
    int* indexes_2 = malloc(sizeof(int)*n_weeks);
    int ptr_1 = 0;
    int ptr_2 = 0;

    for(int i = 0; i < len_edt; i++) {
        if(edt[i].group == g1 && str_equal(edt[i].name, n1)) {
            indexes_1[ptr_1] = i;
            ptr_1++;
        } else if(edt[i].group == g2 && str_equal(edt[i].name, n2)) {
            indexes_2[ptr_2] = i;
            ptr_2++;
        }
    }
    int j = 0;
    for(int i = 0; i < ptr_1; i++) {
        if(j >= ptr_2) {
            free(indexes_1);
            free(indexes_2);
            return false;
        } else {
            int friday_1 = get_next_friday(edt, len_edt, edt[indexes_1[i]].date);
            int friday_2 = get_next_friday(edt, len_edt, edt[indexes_2[j]].date);
            if(friday_1 == friday_2) {
                *p1 = indexes_1[i];
                *p2 = indexes_2[j];

                free(indexes_1);
                free(indexes_2);
                return true;
            } else {
                if(friday_1 > friday_2) {
                    i--;
                    j++;
                }
            }
        }
    }

    free(indexes_1);
    free(indexes_2);
    return false;
}

int** occurencies(creneau* edt, int len_edt, colleur* dudes, int n_groups, int n_colleurs, int n_weeks, bool is_debug) {
    int max_occ = 1;
    int** res = generate_matrix(n_groups, n_colleurs, 0);

    for(int c = 0; c < len_edt; c++) {
        if(edt[c].group != 0) {
            res[edt[c].group-1][get_colleur_id(dudes, n_colleurs, edt[c].name)] += 1;
        }
    }

    bool halt = false;
    for(int it = 0; it < 5*(1-is_debug); it++) {
        for(int grp = 0; grp < n_groups; grp++) {
            for(int dud = 0; dud < n_colleurs; dud++) {
                if(res[grp][dud] > max_occ && get_mat_from_id(dudes, n_colleurs, dud) != INFO) {
                    for(int grp2 = 0; grp2 < n_groups*(1-halt); grp2++) {
                        if(grp2 != grp) {
                            for(int dud2 = 0; dud2 < n_colleurs*(1-halt); dud2++) {
                                if(dud2 != dud && res[grp2][dud2] > max_occ && res[grp][dud2] < max_occ && res[grp2][dud] < max_occ && get_mat_from_id(dudes, n_colleurs, dud) == get_mat_from_id(dudes, n_colleurs, dud2)) {

                                    int id_src;
                                    int id_dest;
                                    if(retreive_indexes(edt, len_edt, &id_src, &id_dest, grp+1, grp2+1, get_name_from_id(dudes, n_colleurs, dud), get_name_from_id(dudes, n_colleurs, dud2), n_weeks)) {;

                                        if(id_src < 0 || id_dest < 0 || id_src >= len_edt || id_dest >= len_edt) {
                                            printf("Uh oh (%d %d)\n", id_src, id_dest);
                                            exit(1);
                                        }

                                        res[grp][dud] -= 1;
                                        res[grp2][dud2] -= 1;
                                        res[grp2][dud] += 1;
                                        res[grp][dud2] += 1;

                                        edt[id_src].group += edt[id_dest].group;
                                        edt[id_dest].group = edt[id_src].group - edt[id_dest].group;
                                        edt[id_src].group -= edt[id_dest].group;

                                        if(is_overlap_creneau(edt, len_edt, id_src, grp2+1)) {
                                            res[grp][dud] -= 1;
                                            res[grp2][dud2] -= 1;
                                            res[grp2][dud] += 1;
                                            res[grp][dud2] += 1;

                                            edt[id_src].group += edt[id_dest].group;
                                            edt[id_dest].group = edt[id_src].group - edt[id_dest].group;
                                            edt[id_src].group -= edt[id_dest].group;
                                        } else if(is_overlap_creneau(edt, len_edt, id_dest, grp+1)) {
                                            res[grp][dud] -= 1;
                                            res[grp2][dud2] -= 1;
                                            res[grp2][dud] += 1;
                                            res[grp][dud2] += 1;

                                            edt[id_src].group += edt[id_dest].group;
                                            edt[id_dest].group = edt[id_src].group - edt[id_dest].group;
                                            edt[id_src].group -= edt[id_dest].group;
                                        } else {
                                            halt = true;
                                            dud--;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                halt = false;
            }
        }
    }

    return res;
}

void copy_matrix(int** src, int lines, int col, int** dest) {
    for(int i = 0; i < lines; i++) {
        for(int j = 0; j < col; j++) {
            dest[i][j] = src[i][j];
        }
    }
}

void aux_2(creneau* edt, int len_edt, colleur* chads, int len_chads, int n_groups, int n_weeks, int n_sim, char* outname, int math_halt, int info_app) {
    
    int start = time(NULL);
    int* weeks_len = malloc(sizeof(int)*n_weeks);
    // this list is used to tell the above code what index of edt it has to go to search for a colle
    int ptr = 0;
    int current = 1;
    for(int k = 1; k < len_edt; k++) {
        if(date_dist(edt[k-1].date, edt[k].date) > 1 || k == len_edt-1) {
            weeks_len[ptr] = current + (k == len_edt - 1);
            current = 0;
            ptr++;
        }
        current++;
    }
    //printf("----------------------------\n");

    int* group_stats = malloc(sizeof(int)*n_groups);
    int* group_temp = malloc(sizeof(int)*n_groups);

    int max_score = -900000;
    int global_min = 0;
    int global_skipped = 0;
    int screwed_group = 0;
    int local_score = 0;
    int local_min = 0;
    int local_group = 0;
    int temp = 0;
    int skipped = 0;
    int a = 0;
    int** occ_data = generate_matrix(n_groups, len_chads, 0);;
    info("Testing %d combinations...", n_sim);
    printf("\n");
    for(int k = 0; k < n_sim*(1 - (max_score == n_groups*100)); k++) {
        if(k >= a) {
            printf("\x1b[1F");
            printf("\x1b[2K");
            info("%d%% Completed (current max is %d/%d)", 100*a/n_sim, max_score, 100*n_groups);
            a += n_sim/100;
        }
        local_score = 0;
        local_min = 100;
        skipped = 0;
        for(int i = 0; i < n_groups; i++) {
            add_colles_for_group_MP2I(weeks_len, edt, len_edt, chads, len_chads, n_weeks, i+1, (topic)(2+i%2), i%math_halt, i%info_app, &skipped, math_halt, info_app);
        }
        int** temp_data = occurencies(edt, len_edt, chads, n_groups, len_chads, n_weeks, false);
        for(int i = 0; i < n_groups; i++) {
            temp = score(edt, len_edt, i+1, n_weeks);
            local_score += temp;
            group_temp[i] = temp;
            if(local_min > temp) {
                local_min = temp;
                local_group = i+1;
            }
        }
        local_score -= skipped*30;
        if(local_score > max_score) {
            max_score = local_score;
            screwed_group = local_group;
            global_min = local_min;
            global_skipped = skipped;
            for(int p = 0; p < n_groups; p++) {
                group_stats[p] = group_temp[p];
            }
            copy_matrix(temp_data, n_groups, len_chads, occ_data);
            write_to_file(outname, edt, len_edt);
        }
        for(int r = 0; r < len_edt; r++) {
            remove_colle(edt, r);
        }
        destroy_matrix(temp_data, n_groups);
    }

    printf("\x1b[1F");
    printf("\x1b[2K");
    if(max_score == 100*n_groups) {
        info("Interrupting early due to a perfect score achieved");
    } else {
        info("100%% Completed, best score is %d/%d (without skip penalty) with %d skipped colle(s)", max_score+global_skipped*30, 100*n_groups, global_skipped);
        info("Most screwed group is %d with a score of %d/100", screwed_group, global_min);
        debug("Stats for all groups are :");
        for(int i = 0; i < n_groups; i++) {
            debug("Group %d : %d/100", i+1, group_stats[i]);
        }
    }
    int end = time(NULL);
    printf("\n");
    info("Here is all data regarding colles occurencies :");
    for(int k = 0; k < n_groups; k++) {
        printf("Group %d : ", (k+1)%10);
        print_arr(occ_data[k], len_chads);
    }
    info("Took %ds to find", end-start);
    free(group_stats);
    free(group_temp);
    free(weeks_len);
    destroy_matrix(occ_data, n_groups);
}