Grading Logic

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

Desafío

Fácil

Ahora que podemos analizar los datos, implementemos un sistema de calificación para asignar calificaciones en letras basadas en las puntuaciones. Crea una clase llamada GradingSystem con estos métodos:

ConvertToLetterGrade(double score): Convierte una puntuación numérica en una calificación en letras según esta escala:
- A: 90-100
- B: 80-89
- C: 70-79
- D: 60-69
- F: 0-59
- Inválido: Devuelve "N/A" para cualquier puntuación inválida (negativa o > 100)
GetStudentGrade(int[][] scoreGrid, int studentIndex): Calcula el promedio de un estudiante y devuelve su calificación en letras. Devuelve "N/A" para índices de estudiante inválidos.
GetClassDistribution(int[][] scoreGrid): Devuelve un arreglo de enteros que representa el conteo de cada calificación en letras en la clase [A, B, C, D, F]. Basado en el promedio de puntuación de cada estudiante.

Pruébalo tú mismo

using System; // No elimines esta línea
public class GradingSystem
{
    public static string ConvertToLetterGrade(double score)
    {
        // Escribe tu código aquí
        
    }
    
    public static string GetStudentGrade(int[][] scoreGrid, int studentIndex)
    {
        // Escribe tu código aquí
        
    }
    
    public static int[] GetClassDistribution(int[][] scoreGrid)
    {
        // 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 asignaciones 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 asignación 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 asignación
        for (int i = 0; i < scoreGrid.Length; i++)
        {
            if (assignmentIndex < scoreGrid[i].Length)
            {
                int score = scoreGrid[i][assignmentIndex];
                if (score != -1)  // Ignorar asignaciones 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 };
    }
}