Berichterstellung
Teil des Abschnitts Logik & Ablauf der C#-Journey von Coddy. Lektion 44 von 66.
Aufgabe
MittelDa wir nun das Bewertungssystem haben, erstellen wir ein Berichtsmodul, das formatierte Berichte zur Leistung der Studierenden generiert. Erstelle eine Klasse namens ReportGenerator mit diesen Methoden:
GenerateStudentReport(int[][] scoreGrid, int studentIndex): Gibt eine formatierte Zeichenfolge zurück, die die Punktzahlen, den Durchschnitt und die Buchstabennote einer bestimmten Person meldet.- Format: "Student #X | Average: YY.Y | Grade: Z\nAssignment scores: S1, S2, S3, ..." wobei S1, S2, S3, ... die numerischen Punktzahlen für jede Aufgabe sind.
- Zeige bei unbewerteten Aufgaben (Punktzahl -1) statt der Punktzahl "N/A" an.
- Gib bei einem ungültigen Studierendenindex "Invalid student index" zurück.
GenerateClassSummary(int[][] scoreGrid): Gibt eine formatierte Zeichenfolge zurück, die die Leistung der Klasse zusammenfasst.- Format: "Class Summary\nTotal Students: X\nClass Average: YY.Y\nGrade Distribution: A: #, B: #, C: #, D: #, F: #"
GenerateAssignmentReport(int[][] scoreGrid, int assignmentIndex): Gibt eine formatierte Zeichenfolge mit Statistiken zu einer bestimmten Aufgabe zurück.- Format: "Assignment #X | Average: YY.Y | Completion Rate: Z%"
- Die Abschlussquote ist der Prozentsatz der Studierenden, die für diese Aufgabe eine Note haben (nicht -1).
- Gib bei einem ungültigen Aufgabenindex "Invalid assignment index" zurück.
Probier es selbst
using System; // Diese Zeile nicht löschen
using System.Text;
public class ReportGenerator
{
public static string GenerateStudentReport(int[][] scoreGrid, int studentIndex)
{
// Schreibe deinen Code hier
}
public static string GenerateClassSummary(int[][] scoreGrid)
{
// Schreibe deinen Code hier
}
public static string GenerateAssignmentReport(int[][] scoreGrid, int assignmentIndex)
{
// Schreibe deinen Code hier
}
}
// Für Tests erforderlich – nicht ändern
public class DataCollector
{
public static int[][] CreateScoreGrid(int students, int assignments)
{
int[][] scoreGrid = new int[students][];
for (int i = 0; i < students; i++)
{
scoreGrid[i] = new int[assignments];
}
return scoreGrid;
}
public static bool ValidateScore(int score)
{
return score >= 0 && score <= 100;
}
public static int[][] PopulateWithDefaultValues(int[][] scoreGrid)
{
for (int i = 0; i < scoreGrid.Length; i++)
{
for (int j = 0; j < scoreGrid[i].Length; j++)
{
scoreGrid[i][j] = -1;
}
}
return scoreGrid;
}
}
public class DataEntry
{
public static int SetStudentScore(int[][] scoreGrid, int studentIndex, int assignmentIndex, int score)
{
// Prüfe, ob Indizes außerhalb des gültigen Bereichs liegen
if (studentIndex < 0 || studentIndex >= scoreGrid.Length ||
assignmentIndex < 0 || assignmentIndex >= scoreGrid[studentIndex].Length)
{
return -1;
}
// Überprüfe die Punktzahl
if (!DataCollector.ValidateScore(score))
{
return -2;
}
// Setze die Punktzahl
scoreGrid[studentIndex][assignmentIndex] = score;
return 0;
}
public static int UpdateAllScores(int[][] scoreGrid, int[] studentIndices, int assignmentIndex, int score)
{
int successCount = 0;
for (int i = 0; i < studentIndices.Length; i++)
{
int result = SetStudentScore(scoreGrid, studentIndices[i], assignmentIndex, score);
if (result == 0)
{
successCount++;
}
}
return successCount;
}
}
public class DataAnalyzer
{
public static double CalculateStudentAverage(int[][] scoreGrid, int studentIndex)
{
// Prüfe, ob der Schülerindex gültig ist
if (studentIndex < 0 || studentIndex >= scoreGrid.Length)
{
return -1;
}
int sum = 0;
int count = 0;
// Berechne die Summe der gültigen Punktzahlen
for (int j = 0; j < scoreGrid[studentIndex].Length; j++)
{
int score = scoreGrid[studentIndex][j];
if (score != -1) // Ignoriere noch nicht bewertete Aufgaben
{
sum += score;
count++;
}
}
// Gib den Durchschnitt zurück oder 0, wenn keine gültigen Punktzahlen vorliegen
return count > 0 ? (double)sum / count : 0;
}
public static double CalculateAssignmentAverage(int[][] scoreGrid, int assignmentIndex)
{
// Prüfe, ob Schüler vorhanden sind
if (scoreGrid.Length == 0)
{
return -1;
}
// Prüfe, ob der Aufgabenindex gültig ist
if (assignmentIndex < 0 || assignmentIndex >= scoreGrid[0].Length)
{
return -1;
}
int sum = 0;
int count = 0;
// Summe der gültigen Punktzahlen für die Aufgabe berechnen
for (int i = 0; i < scoreGrid.Length; i++)
{
if (assignmentIndex < scoreGrid[i].Length)
{
int score = scoreGrid[i][assignmentIndex];
if (score != -1) // Ignoriere noch nicht bewertete Aufgaben
{
sum += score;
count++;
}
}
}
// Gib den Durchschnitt zurück oder 0, wenn keine gültigen Punktzahlen vorliegen
return count > 0 ? (double)sum / count : 0;
}
public static int[] FindHighestScore(int[][] scoreGrid)
{
int highestStudentIndex = 0;
int highestAssignmentIndex = 0;
int highestScore = -1;
// Nach der höchsten Punktzahl suchen
for (int i = 0; i < scoreGrid.Length; i++)
{
for (int j = 0; j < scoreGrid[i].Length; j++)
{
int currentScore = scoreGrid[i][j];
if (currentScore > highestScore)
{
highestScore = currentScore;
highestStudentIndex = i;
highestAssignmentIndex = j;
}
}
}
return new int[] { highestStudentIndex, highestAssignmentIndex, highestScore };
}
}
public class GradingSystem
{
public static string ConvertToLetterGrade(double score)
{
if (score < 0 || score > 100)
{
return "N/A";
}
else if (score >= 90)
{
return "A";
}
else if (score >= 80)
{
return "B";
}
else if (score >= 70)
{
return "C";
}
else if (score >= 60)
{
return "D";
}
else
{
return "F";
}
}
public static string GetStudentGrade(int[][] scoreGrid, int studentIndex)
{
double average = DataAnalyzer.CalculateStudentAverage(scoreGrid, studentIndex);
if (average == -1)
{
return "N/A";
}
return ConvertToLetterGrade(average);
}
public static int[] GetClassDistribution(int[][] scoreGrid)
{
int[] distribution = new int[5]; // [A, B, C, D, F]
for (int i = 0; i < scoreGrid.Length; i++)
{
string grade = GetStudentGrade(scoreGrid, i);
switch (grade)
{
case "A":
distribution[0]++;
break;
case "B":
distribution[1]++;
break;
case "C":
distribution[2]++;
break;
case "D":
distribution[3]++;
break;
case "F":
distribution[4]++;
break;
// Noten mit N/A werden bei der Verteilung nicht mitgezählt
}
}
return distribution;
}
}Alle Lektionen in Logik & Ablauf
1Mehrdimensionale Arrays
Grundlagen 2D-Arrays2D-Arrays deklarieren und initialisierenAuf Elemente von 2D-Arrays zugreifenVerschachtelte Schleifen mit 2D-ArraysGezackte ArraysHäufige MatrixoperationenZusammenfassung – Mehrdimensionale Arrays4Techniken zur Ablaufsteuerung
Frühe RückgabenWächterklauselnSprunganweisungen (goto)Break und ContinueVerschachtelte Bedingungen abflachen7Logische Operatoren – Fortgeschritten
KurzschlussauswertungBedingte logische OperatorenOperatorrangfolgeRückblick – Erweiterte Operatoren2Fortgeschrittene Entscheidungslogik
Mehrere BedingungenKomplexe boolesche LogikVergleich: If vs. SwitchVerschachtelte Switch-AnweisungenRückblick – Fortgeschrittene Entscheidungen5Fehlerbehandlung mit Exceptions
Grundlagen von Try-CatchException-TypenMehrere Catch-BlöckeArbeiten mit DateienFinally-BlockUsing im Vergleich zu Try-FinallyBenutzerdefinierte ExceptionsZusammenfassung – Fehlerbehandlung8Datenanalysesystem
Einrichtung der DatenerfassungLogik der Dateneingabe3Schleifenverbesserungen
SchleifenleistungKomplexe IterationJeder SchleifentypSchleifen refaktorierenRückblick – Optimierte Schleifen6Behandlung von Nullwerten
Grundlagen von NullreferenzenNullable WerttypenMuster zur NullprüfungDefensive ProgrammierungZusammenfassung – NullsicherheitÜbe selbstständig: Online-C#-Compiler