Report Generation

Parte de la sección Lógica y Flujo del Journey de C# de Coddy — lección 44 de 66.

Desafío

Intermedio

Ahora que tenemos el sistema de calificaciones, creemos un módulo de informes para generar informes formateados sobre el rendimiento de los estudiantes. Crea una clase llamada ReportGenerator con estos métodos:

GenerateStudentReport(int[][] scoreGrid, int studentIndex): Devuelve una cadena formateada que informa las puntuaciones, promedio y calificación alfabética de un estudiante específico.
- Formato: "Student #X | Average: YY.Y | Grade: Z\nAssignment scores: S1, S2, S3, ..." donde S1, S2, S3, ... son las puntuaciones numéricas para cada tarea.
- Para tareas no calificadas (puntuación de -1), muestra "N/A" en lugar de la puntuación.
- Devuelve "Invalid student index" para cualquier índice de estudiante inválido.
GenerateClassSummary(int[][] scoreGrid): Devuelve una cadena formateada que resume el rendimiento de la clase.
- Formato: "Class Summary\nTotal Students: X\nClass Average: YY.Y\nGrade Distribution: A: #, B: #, C: #, D: #, F: #"
GenerateAssignmentReport(int[][] scoreGrid, int assignmentIndex): Devuelve una cadena formateada con estadísticas para una tarea específica.
- Formato: "Assignment #X | Average: YY.Y | Completion Rate: Z%"
- La tasa de completitud es el porcentaje de estudiantes que tienen una calificación para esta tarea (no -1).
- Devuelve "Invalid assignment index" para cualquier índice de tarea inválido.

Pruébalo tú mismo

using System; // No elimines esta línea
using System.Text;

public class ReportGenerator
{
    public static string GenerateStudentReport(int[][] scoreGrid, int studentIndex)
    {
        // Escribe tu código aquí
        
    }
    
    public static string GenerateClassSummary(int[][] scoreGrid)
    {
        // Escribe tu código aquí
        
    }
    
    public static string GenerateAssignmentReport(int[][] scoreGrid, int assignmentIndex)
    {
        // Escribe tu código aquí
        
    }
}

// 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)
    {
        // Verificar índices fuera de límites
        if (studentIndex < 0 || studentIndex >= scoreGrid.Length || 
            assignmentIndex < 0 || assignmentIndex >= scoreGrid[studentIndex].Length)
        {
            return -1;
        }
        
        // Validar la puntuación
        if (!DataCollector.ValidateScore(score))
        {
            return -2;
        }
        
        // Establecer la puntuación
        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)
    {
        // Verificar si el índice del estudiante es válido
        if (studentIndex < 0 || studentIndex >= scoreGrid.Length)
        {
            return -1;
        }
        
        int sum = 0;
        int count = 0;
        
        // Calcular suma de puntuaciones válidas
        for (int j = 0; j < scoreGrid[studentIndex].Length; j++)
        {
            int score = scoreGrid[studentIndex][j];
            if (score != -1)  // Ignorar tareas no calificadas
            {
                sum += score;
                count++;
            }
        }
        
        // Devolver promedio o 0 si no hay puntuaciones válidas
        return count > 0 ? (double)sum / count : 0;
    }
    
    public static double CalculateAssignmentAverage(int[][] scoreGrid, int assignmentIndex)
    {
        // Verificar si hay estudiantes
        if (scoreGrid.Length == 0)
        {
            return -1;
        }
        
        // Verificar si el índice de la tarea es válido
        if (assignmentIndex < 0 || assignmentIndex >= scoreGrid[0].Length)
        {
            return -1;
        }
        
        int sum = 0;
        int count = 0;
        
        // Calcular suma de puntuaciones válidas para la tarea
        for (int i = 0; i < scoreGrid.Length; i++)
        {
            if (assignmentIndex < scoreGrid[i].Length)
            {
                int score = scoreGrid[i][assignmentIndex];
                if (score != -1)  // Ignorar tareas no calificadas
                {
                    sum += score;
                    count++;
                }
            }
        }
        
        // Devolver promedio o 0 si no hay puntuaciones válidas
        return count > 0 ? (double)sum / count : 0;
    }
    
    public static int[] FindHighestScore(int[][] scoreGrid)
    {
        int highestStudentIndex = 0;
        int highestAssignmentIndex = 0;
        int highestScore = -1;
        
        // Buscar la puntuación más alta
        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;
                // Las calificaciones N/A no se cuentan en la distribución
            }
        }
        
        return distribution;
    }
}