Berichterstellung

Teil des Abschnitts Logik & Ablauf der C#-Journey von Coddy. Lektion 44 von 66.

Aufgabe

Mittel

Da wir nun das Bewertungssystem haben, erstellen wir ein Berichtsmodul, das formatierte Berichte über die Leistungen der Schülerinnen und Schüler generiert. Erstelle eine Klasse namens ReportGenerator mit diesen Methoden:

GenerateStudentReport(int[][] scoreGrid, int studentIndex): Gibt eine formatierte Zeichenfolge zurück, die die Bewertungen, den Durchschnitt und die Buchstabennote einer bestimmten Schülerin oder eines bestimmten Schülers enthält.
- Format: "Student #X | Average: YY.Y | Grade: Z\nAssignment scores: S1, S2, S3, ..." wobei S1, S2, S3, ... die numerischen Bewertungen für jede Aufgabe sind.
- Zeige bei nicht bewerteten Aufgaben (Bewertung -1) statt der Bewertung "N/A" an.
- Gib bei einem ungültigen Schülerindex "Invalid student index" zurück.
GenerateClassSummary(int[][] scoreGrid): Gibt eine formatierte Zeichenfolge zurück, die die Leistungen 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 für eine bestimmte Aufgabe zurück.
- Format: "Assignment #X | Average: YY.Y | Completion Rate: Z%"
- Die Abschlussquote ist der Prozentsatz der Schülerinnen und Schüler, die für diese Aufgabe eine Bewertung 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
        
    }
}

// Erforderlich für Tests - 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)
    {
        // Auf Indizes außerhalb des gültigen Bereichs prüfen
        if (studentIndex < 0 || studentIndex >= scoreGrid.Length || 
            assignmentIndex < 0 || assignmentIndex >= scoreGrid[studentIndex].Length)
        {
            return -1;
        }
        
        // Die Punktzahl validieren
        if (!DataCollector.ValidateScore(score))
        {
            return -2;
        }
        
        // Die Punktzahl setzen
        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)
    {
        // Check if student index is valid
        if (studentIndex < 0 || studentIndex >= scoreGrid.Length)
        {
            return -1;
        }
        
        int sum = 0;
        int count = 0;
        
        // Summe der gültigen Punktzahlen berechnen
        for (int j = 0; j < scoreGrid[studentIndex].Length; j++)
        {
            int score = scoreGrid[studentIndex][j];
            if (score != -1)  // Unbenotete Aufgaben ignorieren
            {
                sum += score;
                count++;
            }
        }
        
        // Durchschnitt oder 0 zurückgeben, wenn keine gültigen Punktzahlen
        return count > 0 ? (double)sum / count : 0;
    }
    
    public static double CalculateAssignmentAverage(int[][] scoreGrid, int assignmentIndex)
    {
        // Prüfen, ob es Schüler gibt
        if (scoreGrid.Length == 0)
        {
            return -1;
        }
        
        // Check if assignment index is valid
        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)  // Unbenotete Aufgaben ignorieren
                {
                    sum += score;
                    count++;
                }
            }
        }
        
        // Durchschnitt oder 0 zurückgeben, wenn keine gültigen Punktzahlen
        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;
                // N/A grades are not counted in the distribution
            }
        }
        
        return distribution;
    }
}