Grading Logic

Parte da seção Lógica & Fluxo do Journey de C# da Coddy — lição 43 de 66.

Desafio

Fácil

Agora que podemos analisar os dados, vamos implementar um sistema de notas para atribuir notas de letra com base nas pontuações. Crie uma classe chamada GradingSystem com estes métodos:

ConvertToLetterGrade(double score): Converte uma nota numérica em uma nota de letra de acordo com esta escala:
- A: 90-100
- B: 80-89
- C: 70-79
- D: 60-69
- F: 0-59
- Inválido: Retorne "N/A" para qualquer nota inválida (negativa ou > 100)
GetStudentGrade(int[][] scoreGrid, int studentIndex): Calcula a média de um aluno e retorna sua nota de letra. Retorne "N/A" para índices de aluno inválidos.
GetClassDistribution(int[][] scoreGrid): Retorna um array de inteiros representando a contagem de cada nota de letra na turma [A, B, C, D, F]. Baseie isso na nota média de cada aluno.

Experimente você mesmo

using System; // Não apague esta linha
public class GradingSystem
{
    public static string ConvertToLetterGrade(double score)
    {
        // Escreva seu código aqui
        
    }
    
    public static string GetStudentGrade(int[][] scoreGrid, int studentIndex)
    {
        // Escreva seu código aqui
        
    }
    
    public static int[] GetClassDistribution(int[][] scoreGrid)
    {
        // Escreva seu código aqui
        
    }
}

// Necessário para testes - não modifique
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 fora dos limites
        if (studentIndex < 0 || studentIndex >= scoreGrid.Length || 
            assignmentIndex < 0 || assignmentIndex >= scoreGrid[studentIndex].Length)
        {
            return -1;
        }
        
        // Validar a pontuação
        if (!DataCollector.ValidateScore(score))
        {
            return -2;
        }
        
        // Definir a pontuação
        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 se o índice do aluno é válido
        if (studentIndex < 0 || studentIndex >= scoreGrid.Length)
        {
            return -1;
        }
        
        int sum = 0;
        int count = 0;
        
        // Calcular soma das pontuações válidas
        for (int j = 0; j < scoreGrid[studentIndex].Length; j++)
        {
            int score = scoreGrid[studentIndex][j];
            if (score != -1)  // Ignorar tarefas não avaliadas
            {
                sum += score;
                count++;
            }
        }
        
        // Retornar média ou 0 se não houver pontuações válidas
        return count > 0 ? (double)sum / count : 0;
    }
    
    public static double CalculateAssignmentAverage(int[][] scoreGrid, int assignmentIndex)
    {
        // Verificar se há alunos
        if (scoreGrid.Length == 0)
        {
            return -1;
        }
        
        // Verificar se o índice da tarefa é válido
        if (assignmentIndex < 0 || assignmentIndex >= scoreGrid[0].Length)
        {
            return -1;
        }
        
        int sum = 0;
        int count = 0;
        
        // Calcular soma das pontuações válidas da tarefa
        for (int i = 0; i < scoreGrid.Length; i++)
        {
            if (assignmentIndex < scoreGrid[i].Length)
            {
                int score = scoreGrid[i][assignmentIndex];
                if (score != -1)  // Ignorar tarefas não avaliadas
                {
                    sum += score;
                    count++;
                }
            }
        }
        
        // Retornar média ou 0 se não houver pontuações válidas
        return count > 0 ? (double)sum / count : 0;
    }
    
    public static int[] FindHighestScore(int[][] scoreGrid)
    {
        int highestStudentIndex = 0;
        int highestAssignmentIndex = 0;
        int highestScore = -1;
        
        // Procurar pela pontuação mais 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 };
    }
}