Menu
CoddyTech

Berichterstellung

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

challenge icon

Aufgabe

Mittel

Da 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:

  1. 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.
  2. 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: #"
  3. 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

Übe selbstständig: Online-C#-Compiler