Report Generation

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

Aufgabe

Mittel

Nun, da wir das Bewertungssystem haben, lassen Sie uns ein Berichtsmodul erstellen, um formatierte Berichte über die Leistung der Schüler zu generieren. Erstellen Sie eine Klasse namens ReportGenerator mit diesen Methoden:

GenerateStudentReport(int[][] scoreGrid, int studentIndex): Gibt einen formatierten String zurück, der die Noten, den Durchschnitt und die Buchstaben-Note eines bestimmten Schülers berichtet.
- Format: "Student #X | Average: YY.Y | Grade: Z\nAssignment scores: S1, S2, S3, ..." where S1, S2, S3, ... are the numerical scores for each assignment.
- Für unbewertete Aufgaben (Note von -1) wird "N/A" anstelle der Note angezeigt.
- Geben Sie "Invalid student index" für jeden ungültigen Schülerindex zurück.
GenerateClassSummary(int[][] scoreGrid): Gibt einen formatierten String zurück, der die Klassenleistung zusammenfasst.
- Format: "Class Summary\nTotal Students: X\nClass Average: YY.Y\nGrade Distribution: A: #, B: #, C: #, D: #, F: #"
GenerateAssignmentReport(int[][] scoreGrid, int assignmentIndex): Gibt einen formatierten String mit Statistiken für eine bestimmte Aufgabe zurück.
- Format: "Assignment #X | Average: YY.Y | Completion Rate: Z%"
- Die Fertigstellungsrate ist der Prozentsatz der Schüler, die eine Note für diese Aufgabe haben (nicht -1).
- Geben Sie "Invalid assignment index" für jeden ungültigen Aufgabenindex 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)
    {
        // Schreiben Sie Ihren Code hier
        
    }
    
    public static string GenerateClassSummary(int[][] scoreGrid)
    {
        // Schreiben Sie Ihren Code hier
        
    }
    
    public static string GenerateAssignmentReport(int[][] scoreGrid, int assignmentIndex)
    {
        // Schreiben Sie Ihren Code hier
        
    }
}

// Required for testing - do not modify
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)
    {
        // Überprüfen auf Indizes außerhalb der Grenzen
        if (studentIndex < 0 || studentIndex >= scoreGrid.Length || 
            assignmentIndex < 0 || assignmentIndex >= scoreGrid[studentIndex].Length)
        {
            return -1;
        }
        
        // Score validieren
        if (!DataCollector.ValidateScore(score))
        {
            return -2;
        }
        
        // Score 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)
    {
        // Überprüfen, ob der Studentenindex gültig ist
        if (studentIndex < 0 || studentIndex >= scoreGrid.Length)
        {
            return -1;
        }
        
        int sum = 0;
        int count = 0;
        
        // Summe gültiger Scores berechnen
        for (int j = 0; j < scoreGrid[studentIndex].Length; j++)
        {
            int score = scoreGrid[studentIndex][j];
            if (score != -1)  // Nicht bewertete Aufgaben ignorieren
            {
                sum += score;
                count++;
            }
        }
        
        // Durchschnitt zurückgeben oder 0 wenn keine gültigen Scores
        return count > 0 ? (double)sum / count : 0;
    }
    
    public static double CalculateAssignmentAverage(int[][] scoreGrid, int assignmentIndex)
    {
        // Überprüfen, ob Studenten vorhanden sind
        if (scoreGrid.Length == 0)
        {
            return -1;
        }
        
        // Überprüfen, ob der Aufgabenindex gültig ist
        if (assignmentIndex < 0 || assignmentIndex >= scoreGrid[0].Length)
        {
            return -1;
        }
        
        int sum = 0;
        int count = 0;
        
        // Summe gültiger Scores 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)  // Nicht bewertete Aufgaben ignorieren
                {
                    sum += score;
                    count++;
                }
            }
        }
        
        // Durchschnitt zurückgeben oder 0 wenn keine gültigen Scores
        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 Note 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;
    }
}