915 lines
30 KiB
C#
915 lines
30 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
|
|
namespace spplus;
|
|
|
|
public class CourseCrafter
|
|
{
|
|
public class CourseInstance
|
|
{
|
|
public Sport Sport = null!;
|
|
public int Remaining;
|
|
public List<string> Students = new();
|
|
}
|
|
public static List<(int Semester, CourseInstance Instance)> GeneratedCourses
|
|
= new();
|
|
|
|
private static Sport? ResolveSportFromCourseName(string courseName)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(courseName) ||
|
|
string.Equals(courseName, "null", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return Settings.Instance.Sports.FirstOrDefault(sport =>
|
|
string.Equals(sport.Name, courseName, StringComparison.OrdinalIgnoreCase) ||
|
|
sport.AlternativeNames.Any(alt => string.Equals(alt, courseName, StringComparison.OrdinalIgnoreCase)));
|
|
}
|
|
|
|
public static void RebuildGeneratedCoursesFromResults(IEnumerable<Student> importedResults)
|
|
{
|
|
var importedById = importedResults
|
|
.Where(student => !string.IsNullOrWhiteSpace(student.ID))
|
|
.GroupBy(student => student.ID, StringComparer.OrdinalIgnoreCase)
|
|
.ToDictionary(group => group.Key, group => group.First(), StringComparer.OrdinalIgnoreCase);
|
|
|
|
var generatedCourses = new Dictionary<(int Semester, string SportName), CourseInstance>();
|
|
|
|
foreach (var student in Settings.Instance.Students)
|
|
{
|
|
if (!importedById.TryGetValue(student.ID, out var importedStudent))
|
|
continue;
|
|
|
|
for (int semesterIndex = 0; semesterIndex < 4; semesterIndex++)
|
|
{
|
|
if (importedStudent.Result.Length <= semesterIndex)
|
|
continue;
|
|
|
|
var resultName = importedStudent.Result[semesterIndex];
|
|
var sport = ResolveSportFromCourseName(resultName);
|
|
if (sport == null)
|
|
continue;
|
|
|
|
var key = (semesterIndex + 1, sport.Name);
|
|
if (!generatedCourses.TryGetValue(key, out var course))
|
|
{
|
|
course = new CourseInstance
|
|
{
|
|
Sport = sport,
|
|
Students = new List<string>()
|
|
};
|
|
generatedCourses[key] = course;
|
|
}
|
|
|
|
if (!course.Students.Contains(student.ID))
|
|
course.Students.Add(student.ID);
|
|
}
|
|
}
|
|
|
|
GeneratedCourses = generatedCourses
|
|
.Select(entry => (Semester: entry.Key.Semester, Instance: entry.Value))
|
|
.OrderBy(course => course.Semester)
|
|
.ThenBy(course => course.Instance.Sport.Name)
|
|
.ToList();
|
|
}
|
|
|
|
public static void Craft()
|
|
{
|
|
GeneratedCourses = new();
|
|
int globalCount = 0;
|
|
List<(Sport, List<string>)> initial_sportlist = new();
|
|
List<string>[] students_in_semester = new List<string>[4] { new(), new(), new(), new() };
|
|
foreach (var sp in Settings.Instance.Sports)
|
|
{
|
|
initial_sportlist.Add((sp, new()));
|
|
}
|
|
|
|
foreach (Student s in Settings.Instance.Students)
|
|
{
|
|
foreach (var sp in s.SelectedCourseNames)
|
|
{
|
|
foreach (var item in initial_sportlist)
|
|
{
|
|
if (item.Item1.AlternativeNames.Contains(sp))
|
|
{
|
|
item.Item2.Add(s.ID);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
while (!requestExit())
|
|
{
|
|
Console.WriteLine($"Calculating... ({globalCount})");
|
|
foreach (var item in initial_sportlist)
|
|
{
|
|
if (item.Item2.Count >= item.Item1.MinStudents)
|
|
{
|
|
int semester = getSemesterForSport(item.Item1, item.Item2);
|
|
if (semester <= 0) goto semeq0;
|
|
var inst = new CourseInstance();
|
|
inst.Sport = item.Item1;
|
|
inst.Students = new List<string>();
|
|
for (int i = item.Item2.Count - 1; i >= 0; i--)
|
|
{
|
|
if (inst.Students.Count >= inst.Sport.MaxStudents)
|
|
break;
|
|
|
|
string stud = item.Item2[i];
|
|
|
|
if (!students_in_semester[semester - 1].Contains(stud))
|
|
{
|
|
inst.Students.Add(stud);
|
|
students_in_semester[semester - 1].Add(stud);
|
|
item.Item2.RemoveAt(i);
|
|
}
|
|
}
|
|
if (inst.Students.Count < getEffectiveMinStudents(inst.Sport, semester))
|
|
{
|
|
// Rückgängig machen
|
|
foreach (var s in inst.Students)
|
|
{
|
|
students_in_semester[semester - 1].Remove(s);
|
|
item.Item2.Add(s);
|
|
}
|
|
continue; // Kurs nicht erstellen
|
|
}
|
|
GeneratedCourses.Add((semester, inst));
|
|
}
|
|
|
|
semeq0: ;
|
|
}
|
|
}
|
|
|
|
FillExistingCourses();
|
|
|
|
// Kurs umdisponieren (besser verteilen)
|
|
bool changed;
|
|
int maxIterations = 20;
|
|
int iteration = 0;
|
|
|
|
do
|
|
{
|
|
changed = false;
|
|
iteration++;
|
|
|
|
var sports = GeneratedCourses
|
|
.GroupBy(c => c.Instance.Sport.Name);
|
|
|
|
foreach (var sportGroup in sports)
|
|
{
|
|
var courses = sportGroup.ToList();
|
|
|
|
for (int i = 0; i < courses.Count; i++)
|
|
{
|
|
for (int j = 0; j < courses.Count; j++)
|
|
{
|
|
if (i == j) continue;
|
|
|
|
var cA = courses[i];
|
|
var cB = courses[j];
|
|
|
|
if (cA.Instance.Students.Count <= cB.Instance.Students.Count + 1)
|
|
continue;
|
|
|
|
for (int k = cA.Instance.Students.Count - 1; k >= 0; k--)
|
|
{
|
|
string stud = cA.Instance.Students[k];
|
|
|
|
if (!isStudentFree(cB.Semester, stud))
|
|
continue;
|
|
|
|
if (cB.Instance.Students.Count >= cB.Instance.Sport.MaxStudents)
|
|
continue;
|
|
|
|
// Quellkurs darf nicht unter effektives Min fallen
|
|
if (cA.Instance.Students.Count - 1 < getEffectiveMinStudents(cA.Instance.Sport, cA.Semester))
|
|
continue;
|
|
|
|
cA.Instance.Students.RemoveAt(k);
|
|
students_in_semester[cA.Semester - 1].Remove(stud);
|
|
|
|
cB.Instance.Students.Add(stud);
|
|
students_in_semester[cB.Semester - 1].Add(stud);
|
|
|
|
changed = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
} while (changed && iteration < maxIterations);
|
|
|
|
// --- Kurse nachträglich aufteilen, um NumCoursesPerSemester exakt zu erreichen ---
|
|
for (int semester = 1; semester <= 4; semester++)
|
|
{
|
|
int cancel = 0;
|
|
while (GeneratedCourses.Count(c => c.Semester == semester) < Settings.Instance.NumCoursesPerSemester[semester-1])
|
|
{
|
|
cancel++;
|
|
if (cancel >= 20) break;
|
|
|
|
var candidate = GeneratedCourses
|
|
.Where(c => c.Semester == semester)
|
|
.Where(c => c.Instance.Students.Count >= getEffectiveMinStudents(c.Instance.Sport, c.Semester) * 2)
|
|
.Where(c =>
|
|
{
|
|
int sportCount = GeneratedCourses.Count(g =>
|
|
g.Semester == semester &&
|
|
g.Instance.Sport.Name == c.Instance.Sport.Name);
|
|
|
|
int allowed = c.Instance.Sport.Semester[semester - 1];
|
|
return sportCount < allowed;
|
|
})
|
|
.OrderByDescending(c => c.Instance.Students.Count)
|
|
.FirstOrDefault();
|
|
|
|
if (candidate.Instance == null)
|
|
break;
|
|
|
|
var students = candidate.Instance.Students;
|
|
int totalStudents = students.Count;
|
|
int movedCount = totalStudents / 2;
|
|
int remainingCount = totalStudents - movedCount;
|
|
|
|
if (movedCount < getEffectiveMinStudents(candidate.Instance.Sport, candidate.Semester) ||
|
|
remainingCount < getEffectiveMinStudents(candidate.Instance.Sport, candidate.Semester))
|
|
{
|
|
break;
|
|
}
|
|
|
|
var newCourse = new CourseInstance
|
|
{
|
|
Sport = candidate.Instance.Sport,
|
|
Students = new List<string>()
|
|
};
|
|
|
|
var moved = students
|
|
.Skip(remainingCount)
|
|
.Take(movedCount)
|
|
.ToList();
|
|
|
|
foreach (var s in moved)
|
|
{
|
|
candidate.Instance.Students.Remove(s);
|
|
newCourse.Students.Add(s);
|
|
}
|
|
|
|
GeneratedCourses.Add((semester, newCourse));
|
|
}
|
|
}
|
|
|
|
bool rescueChanged;
|
|
do
|
|
{
|
|
rescueChanged = FillExistingCourses();
|
|
|
|
foreach (var item in initial_sportlist)
|
|
{
|
|
if (TryCreateRescueCourse(item.Item1, item.Item2))
|
|
{
|
|
rescueChanged = true;
|
|
}
|
|
}
|
|
} while (rescueChanged);
|
|
|
|
OptimizeStudentWishCoverage();
|
|
|
|
// --- Ringtausch: Schüler mit 4 Wünschen aber < 4 Zuteilungen neu zuordnen ---
|
|
foreach (var student in Settings.Instance.Students)
|
|
{
|
|
if (student.SelectedCourseNames.Count < 4)
|
|
continue;
|
|
|
|
var currentAssignments = GetAssignmentsBySemester(student.ID);
|
|
int currentCount = currentAssignments.Count(a => a != null);
|
|
|
|
if (currentCount >= 4)
|
|
continue;
|
|
|
|
// Alle aktuellen Zuteilungen entfernen (temporär)
|
|
foreach (var assignment in currentAssignments)
|
|
{
|
|
if (assignment == null) continue;
|
|
assignment.Value.Instance.Students.Remove(student.ID);
|
|
students_in_semester[assignment.Value.Semester - 1].Remove(student.ID);
|
|
}
|
|
|
|
// Alle gewünschten Sports ermitteln
|
|
var desiredSports = student.SelectedCourseNames
|
|
.Select(ResolveSportFromSelection)
|
|
.Where(s => s != null)
|
|
.DistinctBy(s => s!.Name)
|
|
.Select(s => s!)
|
|
.ToList();
|
|
|
|
// Kandidatenkurse pro Semester: Kurse mit freiem Platz, die einem Wunschsport entsprechen
|
|
var candidatesPerSemester = new List<(int Semester, CourseInstance Instance)>[4];
|
|
for (int si = 0; si < 4; si++)
|
|
{
|
|
candidatesPerSemester[si] = GeneratedCourses
|
|
.Where(c => c.Semester == si + 1)
|
|
.Where(c => c.Instance.Students.Count < c.Instance.Sport.MaxStudents)
|
|
.Where(c => desiredSports.Any(ds => ds.Name == c.Instance.Sport.Name))
|
|
.ToList();
|
|
candidatesPerSemester[si].Insert(0, default); // default = kein Kurs
|
|
}
|
|
|
|
(int Semester, CourseInstance Instance)?[] bestAssignment = currentAssignments;
|
|
int bestScore = currentCount;
|
|
|
|
int s0 = candidatesPerSemester[0].Count;
|
|
int s1 = candidatesPerSemester[1].Count;
|
|
int s2 = candidatesPerSemester[2].Count;
|
|
int s3 = candidatesPerSemester[3].Count;
|
|
|
|
var sportSelectedCounts = student.SelectedCourseNames
|
|
.Select(ResolveSportFromSelection)
|
|
.Where(sp => sp != null)
|
|
.GroupBy(sp => sp!.Name)
|
|
.ToDictionary(g => g.Key, g => g.Count());
|
|
|
|
for (int i0 = 0; i0 < s0; i0++)
|
|
for (int i1 = 0; i1 < s1; i1++)
|
|
for (int i2 = 0; i2 < s2; i2++)
|
|
for (int i3 = 0; i3 < s3; i3++)
|
|
{
|
|
var c0 = candidatesPerSemester[0][i0];
|
|
var c1 = candidatesPerSemester[1][i1];
|
|
var c2 = candidatesPerSemester[2][i2];
|
|
var c3 = candidatesPerSemester[3][i3];
|
|
|
|
var chosen = new (int Semester, CourseInstance Instance)?[]
|
|
{
|
|
c0.Instance != null ? (c0.Semester, c0.Instance) : null,
|
|
c1.Instance != null ? (c1.Semester, c1.Instance) : null,
|
|
c2.Instance != null ? (c2.Semester, c2.Instance) : null,
|
|
c3.Instance != null ? (c3.Semester, c3.Instance) : null
|
|
};
|
|
|
|
bool valid = true;
|
|
var sportUsageCounts = new Dictionary<string, int>();
|
|
|
|
for (int si = 0; si < 4; si++)
|
|
{
|
|
if (chosen[si] == null) continue;
|
|
string sportName = chosen[si]!.Value.Instance.Sport.Name;
|
|
sportUsageCounts.TryGetValue(sportName, out int used);
|
|
int allowed = sportSelectedCounts.GetValueOrDefault(sportName, 0);
|
|
if (used >= allowed) { valid = false; break; }
|
|
sportUsageCounts[sportName] = used + 1;
|
|
}
|
|
|
|
if (!valid) continue;
|
|
|
|
int score = chosen.Count(c => c != null);
|
|
if (score > bestScore)
|
|
{
|
|
bestScore = score;
|
|
bestAssignment = chosen;
|
|
}
|
|
}
|
|
|
|
// Beste Zuteilung anwenden
|
|
foreach (var assignment in bestAssignment)
|
|
{
|
|
if (assignment == null) continue;
|
|
assignment.Value.Instance.Students.Add(student.ID);
|
|
students_in_semester[assignment.Value.Semester - 1].Add(student.ID);
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Lokale Hilfsfunktionen
|
|
// ---------------------------------------------------------------------------
|
|
|
|
int getEffectiveMinStudents(Sport sport, int semester)
|
|
{
|
|
int reduction = (semester >= 3) ? 2 : 0;
|
|
return Math.Max(1, sport.MinStudents - reduction);
|
|
}
|
|
|
|
bool isStudentFree(int semester, string studentID)
|
|
{
|
|
foreach (var inst in GeneratedCourses)
|
|
{
|
|
if (semester != inst.Semester) continue;
|
|
foreach (string stud in inst.Instance.Students)
|
|
{
|
|
if (stud == studentID) return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool requestExit()
|
|
{
|
|
globalCount++;
|
|
int sum = Settings.Instance.NumCoursesPerSemester[0] + Settings.Instance.NumCoursesPerSemester[1] +
|
|
Settings.Instance.NumCoursesPerSemester[2] + Settings.Instance.NumCoursesPerSemester[3];
|
|
if (GeneratedCourses.Count >= sum) return true;
|
|
|
|
int low = 0;
|
|
foreach (var item in initial_sportlist)
|
|
{
|
|
if (item.Item2.Count < item.Item1.MinStudents) low++;
|
|
}
|
|
|
|
if (low >= initial_sportlist.Count) return true;
|
|
if (globalCount >= 20) return true;
|
|
return false;
|
|
}
|
|
|
|
int total_missing = 0;
|
|
foreach (var tuple in initial_sportlist)
|
|
{
|
|
int[] missingPerSemester = new int[4];
|
|
foreach (var studentId in tuple.Item2.Distinct())
|
|
{
|
|
for (int semesterIndex = 0; semesterIndex < 4; semesterIndex++)
|
|
{
|
|
if (!students_in_semester[semesterIndex].Contains(studentId))
|
|
{
|
|
missingPerSemester[semesterIndex]++;
|
|
total_missing++;
|
|
}
|
|
}
|
|
}
|
|
|
|
MainWindow.Instance.TbResultTextout.Text +=
|
|
$"{tuple.Item1}: {tuple.Item2.Count} remaining ({missingPerSemester[0]},{missingPerSemester[1]},{missingPerSemester[2]},{missingPerSemester[3]})\n";
|
|
}
|
|
MainWindow.Instance.TbResultTextout.Text += $"\n total remaining: {total_missing}";
|
|
|
|
bool FillExistingCourses()
|
|
{
|
|
bool changed = false;
|
|
|
|
foreach (var item in initial_sportlist)
|
|
{
|
|
if (item.Item2.Count == 0)
|
|
continue;
|
|
|
|
foreach (var ci in GeneratedCourses
|
|
.Where(ci => ci.Instance.Sport.Name == item.Item1.Name)
|
|
.OrderBy(ci => ci.Instance.Students.Count))
|
|
{
|
|
int semester = ci.Semester;
|
|
List<string> added = new();
|
|
|
|
foreach (string stud in item.Item2)
|
|
{
|
|
if (ci.Instance.Students.Count >= ci.Instance.Sport.MaxStudents)
|
|
break;
|
|
|
|
if (students_in_semester[semester - 1].Contains(stud))
|
|
continue;
|
|
|
|
ci.Instance.Students.Add(stud);
|
|
students_in_semester[semester - 1].Add(stud);
|
|
added.Add(stud);
|
|
}
|
|
|
|
foreach (string s in added)
|
|
{
|
|
item.Item2.Remove(s);
|
|
changed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
bool TryCreateRescueCourse(Sport sport, List<string> remainingStudents)
|
|
{
|
|
if (remainingStudents.Count == 0)
|
|
return false;
|
|
|
|
for (int semester = 1; semester <= 4; semester++)
|
|
{
|
|
int semesterIndex = semester - 1;
|
|
|
|
if (sport.Semester[semesterIndex] == 0)
|
|
continue;
|
|
|
|
int sportCoursesInSemester = GeneratedCourses.Count(c =>
|
|
c.Semester == semester && c.Instance.Sport.Name == sport.Name);
|
|
if (sportCoursesInSemester >= sport.Semester[semesterIndex])
|
|
continue;
|
|
|
|
if (GeneratedCourses.Count(c => c.Semester == semester) >= Settings.Instance.NumCoursesPerSemester[semester-1])
|
|
continue;
|
|
|
|
var directlyPlaceable = remainingStudents
|
|
.Distinct()
|
|
.Where(studentId => !students_in_semester[semesterIndex].Contains(studentId))
|
|
.ToList();
|
|
|
|
var donorMoves = new List<((int Semester, CourseInstance Instance) Course, string StudentId)>();
|
|
foreach (var course in GeneratedCourses
|
|
.Where(c => c.Instance.Sport.Name == sport.Name && c.Semester != semester)
|
|
.OrderByDescending(c => c.Instance.Students.Count))
|
|
{
|
|
int movableCount = course.Instance.Students.Count - getEffectiveMinStudents(sport, course.Semester);
|
|
if (movableCount <= 0)
|
|
continue;
|
|
|
|
foreach (var studentId in course.Instance.Students.ToList())
|
|
{
|
|
if (movableCount <= 0)
|
|
break;
|
|
|
|
if (students_in_semester[semesterIndex].Contains(studentId))
|
|
continue;
|
|
|
|
donorMoves.Add((course, studentId));
|
|
movableCount--;
|
|
}
|
|
}
|
|
|
|
if (directlyPlaceable.Count + donorMoves.Count < getEffectiveMinStudents(sport, semester))
|
|
continue;
|
|
|
|
var newCourse = new CourseInstance
|
|
{
|
|
Sport = sport,
|
|
Students = new List<string>()
|
|
};
|
|
|
|
foreach (var studentId in directlyPlaceable)
|
|
{
|
|
if (newCourse.Students.Count >= sport.MaxStudents)
|
|
break;
|
|
|
|
newCourse.Students.Add(studentId);
|
|
}
|
|
|
|
foreach (var move in donorMoves)
|
|
{
|
|
if (newCourse.Students.Count >= sport.MaxStudents)
|
|
break;
|
|
|
|
if (newCourse.Students.Contains(move.StudentId))
|
|
continue;
|
|
|
|
move.Course.Instance.Students.Remove(move.StudentId);
|
|
students_in_semester[move.Course.Semester - 1].Remove(move.StudentId);
|
|
newCourse.Students.Add(move.StudentId);
|
|
}
|
|
|
|
if (newCourse.Students.Count < getEffectiveMinStudents(sport, semester))
|
|
continue;
|
|
|
|
foreach (var studentId in newCourse.Students)
|
|
{
|
|
remainingStudents.Remove(studentId);
|
|
students_in_semester[semesterIndex].Add(studentId);
|
|
}
|
|
|
|
GeneratedCourses.Add((semester, newCourse));
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void OptimizeStudentWishCoverage()
|
|
{
|
|
bool changed;
|
|
int iterations = 0;
|
|
|
|
do
|
|
{
|
|
changed = false;
|
|
iterations++;
|
|
|
|
foreach (var student in Settings.Instance.Students)
|
|
{
|
|
if (TryImproveStudentCoverage(student))
|
|
{
|
|
changed = true;
|
|
}
|
|
}
|
|
} while (changed && iterations < 20);
|
|
}
|
|
|
|
bool TryImproveStudentCoverage(Student student)
|
|
{
|
|
var assignments = GetAssignmentsBySemester(student.ID);
|
|
if (assignments.All(a => a != null))
|
|
return false;
|
|
|
|
var openSemesters = Enumerable.Range(0, 4)
|
|
.Where(i => assignments[i] == null)
|
|
.Select(i => i + 1)
|
|
.ToList();
|
|
if (openSemesters.Count == 0)
|
|
return false;
|
|
|
|
var assignedSports = assignments
|
|
.Where(a => a != null)
|
|
.Select(a => a!.Value.Instance.Sport.Name)
|
|
.ToHashSet();
|
|
|
|
var preferredSports = student.SelectedCourseNames
|
|
.Select(ResolveSportFromSelection)
|
|
.Where(sport => sport != null)
|
|
.DistinctBy(sport => sport!.Name)
|
|
.Select(sport => sport!)
|
|
.Where(sport => !assignedSports.Contains(sport.Name))
|
|
.ToList();
|
|
|
|
foreach (var desiredSport in preferredSports)
|
|
{
|
|
for (int sourceSemester = 1; sourceSemester <= 4; sourceSemester++)
|
|
{
|
|
var currentCourse = assignments[sourceSemester - 1];
|
|
if (currentCourse == null)
|
|
continue;
|
|
|
|
var currentCourseValue = currentCourse.Value;
|
|
|
|
var desiredCourse = GeneratedCourses
|
|
.FirstOrDefault(course =>
|
|
course.Semester == sourceSemester &&
|
|
course.Instance.Sport.Name == desiredSport.Name &&
|
|
course.Instance.Students.Count < course.Instance.Sport.MaxStudents);
|
|
|
|
if (desiredCourse.Instance == null)
|
|
continue;
|
|
|
|
foreach (var targetSemester in openSemesters)
|
|
{
|
|
var relocationTarget = GeneratedCourses
|
|
.FirstOrDefault(course =>
|
|
course.Semester == targetSemester &&
|
|
course.Instance.Sport.Name == currentCourseValue.Instance.Sport.Name &&
|
|
course.Instance.Students.Count < course.Instance.Sport.MaxStudents);
|
|
|
|
if (relocationTarget.Instance == null)
|
|
continue;
|
|
|
|
if (!CanRelocateStudent(student.ID, currentCourseValue, relocationTarget))
|
|
continue;
|
|
|
|
currentCourseValue.Instance.Students.Remove(student.ID);
|
|
students_in_semester[sourceSemester - 1].Remove(student.ID);
|
|
|
|
relocationTarget.Instance.Students.Add(student.ID);
|
|
students_in_semester[targetSemester - 1].Add(student.ID);
|
|
|
|
desiredCourse.Instance.Students.Add(student.ID);
|
|
students_in_semester[sourceSemester - 1].Add(student.ID);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CanRelocateStudent(
|
|
string studentId,
|
|
(int Semester, CourseInstance Instance) sourceCourse,
|
|
(int Semester, CourseInstance Instance) targetCourse)
|
|
{
|
|
if (sourceCourse.Semester == targetCourse.Semester)
|
|
return false;
|
|
|
|
if (sourceCourse.Instance.Students.Count - 1 < getEffectiveMinStudents(sourceCourse.Instance.Sport, sourceCourse.Semester))
|
|
return false;
|
|
|
|
if (targetCourse.Instance.Students.Count >= targetCourse.Instance.Sport.MaxStudents)
|
|
return false;
|
|
|
|
if (!isStudentFree(targetCourse.Semester, studentId))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
(int Semester, CourseInstance Instance)?[] GetAssignmentsBySemester(string studentId)
|
|
{
|
|
var assignments = new (int Semester, CourseInstance Instance)?[4];
|
|
|
|
foreach (var course in GeneratedCourses)
|
|
{
|
|
if (course.Instance.Students.Contains(studentId))
|
|
{
|
|
assignments[course.Semester - 1] = course;
|
|
}
|
|
}
|
|
|
|
return assignments;
|
|
}
|
|
|
|
Sport? ResolveSportFromSelection(string selectedCourseName)
|
|
{
|
|
return ResolveSportFromCourseName(selectedCourseName);
|
|
}
|
|
|
|
int getSemesterForSport(Sport sp, List<string> interestedStudents)
|
|
{
|
|
int[] totalCoursesPerSemester = new int[4];
|
|
foreach (var inst in GeneratedCourses)
|
|
totalCoursesPerSemester[inst.Semester - 1]++;
|
|
|
|
int bestSem = 0;
|
|
int minCourses = int.MaxValue;
|
|
int maxFreeInterestedStudents = -1;
|
|
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
if (sp.Semester[i] == 0)
|
|
continue;
|
|
|
|
int semesterNumber = i + 1;
|
|
|
|
int sportCoursesInThisSemester = GeneratedCourses
|
|
.Count(g => g.Semester == semesterNumber &&
|
|
g.Instance.Sport.Name == sp.Name);
|
|
|
|
if (sportCoursesInThisSemester >= sp.Semester[i])
|
|
continue;
|
|
|
|
if (totalCoursesPerSemester[i] >= Settings.Instance.NumCoursesPerSemester[i])
|
|
continue;
|
|
|
|
int freeInterestedStudents = interestedStudents
|
|
.Distinct()
|
|
.Count(studentId => !students_in_semester[i].Contains(studentId));
|
|
|
|
if (freeInterestedStudents < getEffectiveMinStudents(sp, semesterNumber))
|
|
continue;
|
|
|
|
if (freeInterestedStudents > maxFreeInterestedStudents ||
|
|
(freeInterestedStudents == maxFreeInterestedStudents &&
|
|
totalCoursesPerSemester[i] < minCourses))
|
|
{
|
|
maxFreeInterestedStudents = freeInterestedStudents;
|
|
minCourses = totalCoursesPerSemester[i];
|
|
bestSem = semesterNumber;
|
|
}
|
|
}
|
|
|
|
return bestSem;
|
|
}
|
|
|
|
ReloadResult();
|
|
}
|
|
|
|
public static void ReloadResult()
|
|
{
|
|
var errors = ValidateCourses(GeneratedCourses);
|
|
|
|
if (errors.Count == 0)
|
|
{
|
|
MainWindow.Instance.TbResultLog.Text = "--- Alle generierten Kursen erfüllen die gegebenen Voraussetzungen ---";
|
|
}
|
|
else
|
|
{
|
|
MainWindow.Instance.TbResultLog.Text = "--- Bei der Generierung sind folgende Fehler aufgetreten: ---\n\n";
|
|
foreach (var e in errors)
|
|
MainWindow.Instance.TbResultLog.Text += e + "\n";
|
|
}
|
|
|
|
foreach (var student in Settings.Instance.Students)
|
|
{
|
|
student.Result = new string[4];
|
|
}
|
|
|
|
foreach (var course in GeneratedCourses)
|
|
{
|
|
foreach (var student in Settings.Instance.Students)
|
|
{
|
|
if (course.Instance.Students.Contains(student.ID))
|
|
{
|
|
student.Result[course.Semester - 1] = course.Instance.Sport.Name;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public static string GenerateStatistics()
|
|
{
|
|
GeneratedCourses.Sort((x,y) => x.Semester.CompareTo(y.Semester) );
|
|
string sb = $"Generierte Kurse: {GeneratedCourses.Count}\n\n";
|
|
foreach (var genc in GeneratedCourses)
|
|
{
|
|
sb += $"Sem. {genc.Semester}: {genc.Instance.Sport.Name} ({genc.Instance.Students.Count} SuS)\n";
|
|
}
|
|
|
|
|
|
|
|
return sb;
|
|
}
|
|
|
|
public static List<string> ValidateCourses(List<(int Semester, CourseInstance Instance)> courses)
|
|
{
|
|
List<string> errors = new();
|
|
|
|
// --- 1. Min/Max + Semester erlaubt ---
|
|
foreach (var tuple in courses)
|
|
{
|
|
int semester = tuple.Semester;
|
|
var inst = tuple.Instance;
|
|
var sport = inst.Sport;
|
|
|
|
if (inst.Students.Count < sport.MinStudents)
|
|
{
|
|
errors.Add($"[Min] {sport.Name} (Sem {semester}): {inst.Students.Count} < {sport.MinStudents}");
|
|
}
|
|
|
|
if (inst.Students.Count > sport.MaxStudents)
|
|
{
|
|
errors.Add($"[Max] {sport.Name} (Sem {semester}): {inst.Students.Count} > {sport.MaxStudents}");
|
|
}
|
|
|
|
if (sport.Semester[semester - 1] == 0)
|
|
{
|
|
errors.Add($"[Semester] {sport.Name} darf nicht in Semester {semester} stattfinden");
|
|
}
|
|
|
|
// --- doppelte Schüler im selben Kurs ---
|
|
for (int i = 0; i < inst.Students.Count; i++)
|
|
{
|
|
for (int j = i + 1; j < inst.Students.Count; j++)
|
|
{
|
|
if (inst.Students[i] == inst.Students[j])
|
|
{
|
|
errors.Add($"[Kurs-Duplikat] {inst.Students[i]} mehrfach in {sport.Name} (Sem {semester})");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// --- 2. Schüler doppelt im Semester ---
|
|
for (int sem = 1; sem <= 4; sem++)
|
|
{
|
|
List<string> students = new();
|
|
|
|
foreach (var tuple in courses)
|
|
{
|
|
if (tuple.Semester != sem) continue;
|
|
|
|
foreach (var stud in tuple.Instance.Students)
|
|
{
|
|
// prüfen ob schon drin
|
|
bool exists = false;
|
|
foreach (var s in students)
|
|
{
|
|
if (s == stud)
|
|
{
|
|
exists = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (exists)
|
|
{
|
|
errors.Add($"[Doppelt] Schüler {stud} doppelt in Semester {sem}");
|
|
}
|
|
else
|
|
{
|
|
students.Add(stud);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// --- 3. Sport-Angebote pro Semester zählen ---
|
|
// (ohne Dictionary: wir iterieren über alle Kurse und zählen jeweils erneut)
|
|
|
|
foreach (var tuple in courses)
|
|
{
|
|
int semester = tuple.Semester;
|
|
var sport = tuple.Instance.Sport;
|
|
|
|
int count = 0;
|
|
|
|
foreach (var other in courses)
|
|
{
|
|
if (other.Semester == semester &&
|
|
other.Instance.Sport.Name == sport.Name)
|
|
{
|
|
count++;
|
|
}
|
|
}
|
|
|
|
int allowed = sport.Semester[semester - 1];
|
|
|
|
if (count > allowed)
|
|
{
|
|
errors.Add($"[Sport-Semester] {sport.Name} in Sem {semester}: {count} Kurse > erlaubt {allowed}");
|
|
}
|
|
}
|
|
|
|
return errors;
|
|
}
|
|
}
|