Buckets:
| using namespace std; | |
| // for choosing time in week | |
| typedef pair<int, int> timeInWeek; | |
| // this is for times in class teacher name : class name | |
| typedef pair<string, string> Class; | |
| const int NUMBER_OF_DAY_IN_WEEK = 5; | |
| string DAYS_IN_WEEK[5] = {"Saturday", "Sunday", "Monday", "Tuesday", "Wednesday"}; | |
| struct Time | |
| { | |
| int hour; | |
| int minute; | |
| }; | |
| struct teacher | |
| { | |
| string teacher_name; | |
| vector<string> lesson; | |
| bool times[5][3] = {{false, false, false}, {false, false, false}, {false, false, false}, {false, false, false}, {false, false, false}}; | |
| int numberOfDayInWeek; | |
| }; | |
| struct lesson | |
| { | |
| string lesson_name; | |
| int day1; | |
| int day2; | |
| bool times[5][3] = {{false, false, false}, {false, false, false}, {false, false, false}, {false, false, false}, {false, false, false}}; | |
| bool isChoos[2] = {false, false}; | |
| string teacher_name[2]; | |
| pair<int, int> timeThatChoos[2] ; | |
| }; | |
| int choose_teacher(int day, int bell, vector<teacher> &teachers, lesson lesson , vector<vector<vector<bool>>> &classs , int classNumber); | |
| void print_out_put(vector<lesson> lessons); | |
| bool my_cmp(const lesson& a, const lesson& b); | |
| void print_out_put(vector<lesson> lessons); | |
| string date_to_string(int x); | |
| void put_teachers_times_false(teacher &teacher , lesson lesson , int bell); | |
| void getDaysForTeacher(teacher &teacherTemp, int numberOfDays); | |
| void get_teachers_input(vector<teacher> &teachers); | |
| void fill_bell(bool day[3], Time startTime, Time EndTime); | |
| void set_time_for_lesson(lesson &lesson); | |
| void print_lessons_data(vector<lesson> lessons); | |
| void get_lesson_input(vector<lesson> &lessons); | |
| Time string_to_time(string time); | |
| void fill_bell_for_lessons(int day1, int day2, bool times[5][3]); | |
| void print_teachers_data(vector<teacher> teachers); | |
| bool checkTeacherLesson(vector<teacher> &teachers, vector<lesson> lessons, int day, int bell , int classNumber); | |
| int cheack_lessons_with_alphabets(vector<lesson> lvec); | |
| int cheack_teachers_with_alphabets(vector<teacher> tvec); | |
| int choose_lesson(int day, int bell, vector<lesson> &lessons , int classNumber); | |
| bool isAllTeachersDayEqual(vector<teacher> tvec); | |
| int biggestNumberOfDay(vector<teacher> tvec); | |
| void choose(vector<teacher> &teachers, vector<lesson> &lessons, vector<vector<vector<bool>>> &classs); | |
| void choose_chos(vector<teacher> &teachers, vector<lesson> &lessons, vector<vector<vector<bool>>> &classs); | |
| int checkTeacherWithLesson(int day, int bell, vector<teacher> &teachers, lesson lesson , vector<vector<vector<bool>>> &classs , int classNumber); | |
| int checkEachTeacherWithLesson(int day, int bell, teacher teachers, lesson lesson , vector<vector<vector<bool>>> &classs , int classNumber ); | |
| int main() | |
| { | |
| // we have 2 classes | |
| // for input of classes teache name : lesson name | |
| // bool classs [2][5][3]={{{true,true,true},{true,true,true},{true,true,true},{true,true,true},{true,true,true}},{{true,true,true},{true,true,true},{true,true,true},{true,true,true},{true,true,true}}}; | |
| vector<vector< vector<bool> > > bclass; | |
| vector<bool> b1vec; | |
| vector< vector<bool> > b2vec; | |
| for (int i = 0; i < 3; i++) | |
| { | |
| b1vec.push_back(true); | |
| } | |
| for (int i = 0; i < 5; i++) | |
| { | |
| b2vec.push_back(b1vec); | |
| } | |
| for (int i = 0; i < 2; i++) | |
| { | |
| bclass.push_back(b2vec); | |
| } | |
| // // bool classs[2][5][3]; | |
| // for (int i = 0; i < 2; i++) | |
| // { | |
| // for (int j = 0; j < 5; j++) | |
| // { | |
| // for (int p = 0; p < 3; p++) | |
| // { | |
| // cout << bclass[i][j][p]; | |
| // } | |
| // cout << endl; | |
| // } | |
| // cout << endl; | |
| // } | |
| vector<teacher> teachers; | |
| vector<lesson> lessons; | |
| get_teachers_input(teachers); | |
| get_lesson_input(lessons); | |
| choose(teachers, lessons, bclass); | |
| // print_lessons_data(lessons); | |
| // print_teachers_data(teachers); | |
| print_out_put(lessons); | |
| // for (int i = 0; i < 2; i++) | |
| // { | |
| // for (int j = 0; j < 5; j++) | |
| // { | |
| // for (int p = 0; p < 3; p++) | |
| // { | |
| // cout << bclass[i][j][p]; | |
| // } | |
| // cout << endl; | |
| // } | |
| // cout << endl; | |
| // } | |
| } | |
| // for put days of each teache in time attrebute | |
| void getDaysForTeacher(teacher &teacherTemp, int numberOfDays) | |
| { | |
| string dayTemp; | |
| for (int i = 0; i < numberOfDays; i++) | |
| { | |
| cin >> dayTemp; | |
| for (int p = 0; p < NUMBER_OF_DAY_IN_WEEK; p++) | |
| { | |
| if (dayTemp == DAYS_IN_WEEK[p]) | |
| { | |
| for (int c = 0; c < 3; c++) | |
| { | |
| teacherTemp.times[p][c] = true; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| // for each line | |
| void get_teachers_input(vector<teacher> &teachers) | |
| { | |
| string stemp; | |
| int itemp; | |
| int numberOfTeachers; | |
| cin >> numberOfTeachers; | |
| for (int i = 0; i < numberOfTeachers; i++) | |
| { | |
| teacher teacherTemp; | |
| cin >> stemp; | |
| teacherTemp.teacher_name = stemp; | |
| cin >> itemp; | |
| teacherTemp.numberOfDayInWeek = itemp; | |
| getDaysForTeacher(teacherTemp, itemp); | |
| cin >> itemp; | |
| for (int i = 0; i < itemp; i++) | |
| { | |
| cin >> stemp; | |
| teacherTemp.lesson.push_back(stemp); | |
| } | |
| teachers.push_back(teacherTemp); | |
| } | |
| } | |
| //<<<<<<<<<<<<<< | |
| void fill_bell(bool day[3], Time startTime, Time EndTime) | |
| { | |
| float sTime = startTime.hour + (float(startTime.minute) / 60); | |
| float eTime = EndTime.hour + (float(EndTime.minute) / 60); | |
| // cout << sTime << " " << eTime << endl ; | |
| if ((sTime <= 7.5) && (eTime >= 9)) | |
| { | |
| day[0] = true; | |
| } | |
| if ((sTime <= 9.5) && (eTime >= 11)) | |
| { | |
| day[1] = true; | |
| } | |
| if ((sTime <= 11.5) && (eTime >= 13)) | |
| { | |
| day[2] = true; | |
| } | |
| } | |
| //<<<<<<<<<<<<<< | |
| Time string_to_time(string time) | |
| { | |
| stringstream stime(time); | |
| Time TempTime; | |
| string hour, minute; | |
| getline(stime, hour, ':'); | |
| getline(stime, minute); | |
| TempTime.hour = stoi(hour); | |
| TempTime.minute = stoi(minute); | |
| return TempTime; | |
| } | |
| void fill_bell_for_lessons(int day1, int day2, bool times[5][3]) | |
| { | |
| string startTime, endTime; | |
| cin >> startTime; | |
| cin >> endTime; | |
| fill_bell(times[day1], string_to_time(startTime), string_to_time(endTime)); | |
| fill_bell(times[day2], string_to_time(startTime), string_to_time(endTime)); | |
| } | |
| void set_time_for_lesson(lesson &lesson) | |
| { | |
| string day1; | |
| string day2; | |
| vector<int> IntDaysInWeek; | |
| cin >> day1; | |
| cin >> day2; | |
| for (int i = 0; i < NUMBER_OF_DAY_IN_WEEK; i++) | |
| { | |
| if (DAYS_IN_WEEK[i] == day1 || DAYS_IN_WEEK[i] == day2) | |
| { | |
| IntDaysInWeek.push_back(i); | |
| } | |
| } | |
| lesson.day1=IntDaysInWeek[0]; | |
| lesson.day2=IntDaysInWeek[1]; | |
| fill_bell_for_lessons(IntDaysInWeek[0], IntDaysInWeek[1], lesson.times); | |
| } | |
| void print_lessons_data(vector<lesson> lessons) | |
| { | |
| for (int i = 0; i < lessons.size(); i++) | |
| { | |
| cout << endl; | |
| cout << lessons[i].lesson_name << endl; | |
| for (int p = 0; p < 5; p++) | |
| { | |
| for (int q = 0; q < 3; q++) | |
| { | |
| cout << lessons[i].times[p][q] << " "; | |
| } | |
| cout << endl; | |
| } | |
| cout << lessons[i].teacher_name[0] << " " << lessons[i].timeThatChoos[0].first << lessons[i].timeThatChoos[0].second << lessons[i].isChoos[1] << endl ; | |
| cout << lessons[i].teacher_name[1] << " " << lessons[i].timeThatChoos[1].first << lessons[i].timeThatChoos[1].second << lessons[i].isChoos[1] << endl ; | |
| } | |
| } | |
| void get_lesson_input(vector<lesson> &lessons) | |
| { | |
| int itemp; | |
| string stemp; | |
| int NUmOfLessons; | |
| cin >> NUmOfLessons; | |
| for (int p = 0; p < NUmOfLessons; p++) | |
| { | |
| lesson lessonTemp={}; | |
| cin >> stemp; | |
| lessonTemp.lesson_name = stemp; | |
| set_time_for_lesson(lessonTemp); | |
| lessons.push_back(lessonTemp); | |
| } | |
| } | |
| void print_teachers_data(vector<teacher> teachers) | |
| { | |
| cout << teachers.size() << endl; | |
| for (int i = 0; i < teachers.size(); i++) | |
| { | |
| cout << teachers[i].teacher_name << endl; | |
| for (int p = 0; p < 5; p++) | |
| { | |
| for (int q = 0; q < 3; q++) | |
| { | |
| cout << teachers[i].times[p][q]; | |
| } | |
| cout << endl; | |
| } | |
| cout << endl; | |
| } | |
| } | |
| bool checkTeacherLesson(vector<teacher> &teachers, vector<lesson> lessons, int day, int bell , int classNumber) | |
| { | |
| for (int i = 0; i < lessons.size(); i++) | |
| { | |
| if (lessons[i].times[day][bell] == true && !lessons[i].isChoos[classNumber]) | |
| { | |
| for (int p = 0; p < teachers.size(); p++) | |
| { | |
| if (teachers[p].times[day][bell] == true) | |
| { | |
| return true; | |
| } | |
| } | |
| } | |
| } | |
| return false; | |
| } | |
| int cheack_lessons_with_alphabets(vector<lesson> lvec) | |
| { | |
| int iTemp = 0; | |
| for (int i = 0; i < lvec.size(); i++) | |
| { | |
| if (lvec[iTemp].lesson_name.compare(lvec[i].lesson_name) <= 0) | |
| { | |
| iTemp = i; | |
| } | |
| } | |
| return iTemp; | |
| } | |
| int cheack_teachers_with_alphabets(vector<teacher> tvec) | |
| { | |
| int iTemp = 0; | |
| for (int i = 0; i < tvec.size(); i++) | |
| { | |
| if (tvec[iTemp].teacher_name.compare(tvec[i].teacher_name) > 0) | |
| { | |
| iTemp = i; | |
| } | |
| } | |
| return iTemp; | |
| } | |
| int choose_lesson(int day, int bell, vector<lesson> &lessons , int classNumber) | |
| { | |
| vector<lesson> lessonsTemp; // valid lessons in vector | |
| vector<int> lessonNumber; | |
| // for check lessons that are currect | |
| for (int i = 0; i < lessons.size(); i++) | |
| { | |
| if (lessons[i].times[lessons[i].day1][bell] && lessons[i].times[lessons[i].day1][bell] && !lessons[i].isChoos[classNumber]) | |
| { | |
| lessonsTemp.push_back(lessons[i]); | |
| lessonNumber.push_back(i); | |
| } | |
| } | |
| if (lessonsTemp.size() == 1) | |
| { | |
| return lessonNumber[0]; | |
| } | |
| else | |
| { | |
| // cout << lessonsTemp.size() << lessonsTemp[0].lesson_name << lessonsTemp[1].lesson_name << "lessonsTemp.size() nnnnnnnnnnnn"; | |
| return lessonNumber[cheack_lessons_with_alphabets(lessonsTemp)]; | |
| } | |
| } | |
| // for check that we have teacher with that time and lesson or noot | |
| int checkEachTeacherWithLesson(int day, int bell, teacher teachers, lesson lesson , vector<vector<vector<bool>>> &classs , int classNumber ) | |
| { | |
| for (int p = 0; p < teachers.lesson.size(); p++) | |
| { | |
| if ((teachers.lesson[p] == lesson.lesson_name) && teachers.times[lesson.day1][bell] && teachers.times[lesson.day2][bell] && classs[classNumber][lesson.day1][bell] && classs[classNumber][lesson.day2][bell] ) | |
| { | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool isAllTeachersDayEqual(vector<teacher> tvec) | |
| { | |
| int iTemp = tvec[0].numberOfDayInWeek; | |
| for (int i = 0; i < tvec.size(); i++) | |
| { | |
| if (iTemp != tvec[i].numberOfDayInWeek) | |
| { | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| int biggestNumberOfDay(vector<teacher> tvec) | |
| { | |
| int iTemp = 0; | |
| int numberOfTeacher = 0; | |
| for (int i = 0; i < tvec.size(); i++) | |
| { | |
| if (iTemp > tvec[i].numberOfDayInWeek) | |
| { | |
| iTemp = tvec[i].numberOfDayInWeek; | |
| numberOfTeacher = i; | |
| } | |
| } | |
| return numberOfTeacher; | |
| } | |
| int choose_teacher(int day, int bell, vector<teacher> &teachers, lesson lesson , vector<vector<vector<bool>>> &classs , int classNumber) | |
| { | |
| vector<teacher> teachersTemp; // valid teacher in vector | |
| vector<int> teachersNumber; | |
| bool lessonFlag = false; | |
| for (int i = 0; i < teachers.size(); i++) | |
| { | |
| if (checkEachTeacherWithLesson(day, bell, teachers[i], lesson,classs,classNumber)) | |
| { | |
| teachersTemp.push_back(teachers[i]); | |
| teachersNumber.push_back(i); | |
| } | |
| } | |
| if (teachersTemp.size() == 1) | |
| { | |
| return teachersNumber[0]; | |
| } | |
| if (!isAllTeachersDayEqual(teachersTemp)) // مساوی نبود | |
| { | |
| return teachersNumber[biggestNumberOfDay(teachersTemp)]; | |
| } | |
| // مساوی بود | |
| return teachersNumber[cheack_teachers_with_alphabets(teachersTemp)]; | |
| } | |
| // for check that we have teacher with that time and lesson or noot | |
| int checkTeacherWithLesson(int day, int bell, vector<teacher> &teachers, lesson lesson , vector<vector<vector<bool>>> &classs , int classNumber) | |
| { | |
| for (int i = 0; i < teachers.size(); i++) | |
| { | |
| for (int p = 0; p < teachers[i].lesson.size(); p++) | |
| { | |
| if ((teachers[i].lesson[p] == lesson.lesson_name) && teachers[i].times[lesson.day1][bell] && teachers[i].times[lesson.day2][bell] && classs[classNumber][lesson.day1][bell] && classs[classNumber][lesson.day2][bell] ) | |
| { | |
| return true; | |
| } | |
| } | |
| } | |
| return false; | |
| } | |
| void put_teachers_times_false(teacher &teacher , lesson lesson , int bell){ | |
| // cout << lesson.day1 << lesson.day2 ; | |
| teacher.times[lesson.day1][bell]=false; | |
| teacher.times[lesson.day2][bell]=false; | |
| // cout << endl << "final teacher time" << endl ; | |
| // for (int i = 0; i < 5; i++) | |
| // { | |
| // for (int p = 0; p < 3; p++) | |
| // { | |
| // cout << teacher.times[i][p] << " "; | |
| // } | |
| // cout << endl; | |
| // } | |
| } | |
| void choose(vector<teacher> &teachers, vector<lesson> &lessons, vector<vector<vector<bool>>> &classs) | |
| { | |
| int teacherNumber; | |
| int lessonNumber; | |
| for (int classNomber = 0; classNomber < 2; classNomber++) | |
| { | |
| for (int dayNomber = 0; dayNomber < 5; dayNomber++) | |
| { | |
| for (int bell = 0; bell < 3; bell++) | |
| { | |
| if (classs[classNomber][dayNomber][bell]==true) | |
| { | |
| if (checkTeacherLesson(teachers, lessons, dayNomber, bell , classNomber)) | |
| { | |
| // for number of teacher and lesson in this time in week | |
| lessonNumber = choose_lesson(dayNomber, bell, lessons , classNomber); | |
| if (checkTeacherWithLesson(dayNomber, bell, teachers, lessons[lessonNumber],classs,classNomber)) | |
| { | |
| teacherNumber = choose_teacher(dayNomber, bell, teachers, lessons[lessonNumber],classs,classNomber); | |
| // cout << endl << lessonNumber << " " << classNomber << " " << dayNomber << " " << bell << " " << teachers[teacherNumber].teacher_name << " ..." << endl; | |
| classs[classNomber][lessons[lessonNumber].day1][bell] = false; | |
| classs[classNomber][lessons[lessonNumber].day2][bell] = false; | |
| lessons[lessonNumber].isChoos[classNomber] = true; | |
| lessons[lessonNumber].teacher_name[classNomber] = teachers[teacherNumber].teacher_name; | |
| lessons[lessonNumber].timeThatChoos[classNomber] = make_pair(dayNomber, bell); | |
| put_teachers_times_false(teachers[teacherNumber],lessons[lessonNumber],bell); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| bool my_cmp(const lesson& a, const lesson& b) | |
| { | |
| // smallest comes first | |
| return (a.lesson_name.compare(b.lesson_name))<=0 ; | |
| } | |
| string date_to_string(int x){ | |
| string sTemp; | |
| if (x==0) | |
| { | |
| sTemp = "07:30 09:00"; | |
| }else if (x==1) | |
| { | |
| sTemp = "09:30 11:00"; | |
| } | |
| else if(x==2){ | |
| sTemp = "11:30 13:00"; | |
| } | |
| return sTemp; | |
| } | |
| void print_out_put(vector<lesson> lessons){ | |
| vector<lesson> lessonsTemp = lessons; | |
| // cout << endl << endl ; | |
| sort(lessonsTemp.begin(),lessonsTemp.end(),my_cmp); | |
| for (int i = 0; i < lessonsTemp.size(); i++) | |
| { | |
| cout << lessonsTemp[i].lesson_name << endl; | |
| if (lessonsTemp[i].isChoos[0]) | |
| { | |
| cout << lessonsTemp[i].teacher_name[0] << ": " << date_to_string(lessonsTemp[i].timeThatChoos[0].second) << endl; | |
| }else{ | |
| cout << "Not Found" << endl; | |
| } | |
| if (lessonsTemp[i].isChoos[1]) | |
| { | |
| cout << lessonsTemp[i].teacher_name[1] << ": " << date_to_string(lessonsTemp[i].timeThatChoos[1].second) << endl; | |
| }else{ | |
| cout << "Not Found" << endl; | |
| } | |
| } | |
| } |
Xet Storage Details
- Size:
- 16.6 kB
- Xet hash:
- 5d91d6f0aab8483212aff122988bb436db9d0a57258fb8173f435611a3fa700d
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.