Students and Examinations: Analyzing Exam Results

This challenge focuses on processing student examination data to determine class averages, identify students who performed poorly, and calculate the distribution of scores. It's a common task in educational institutions for tracking student progress and identifying areas needing improvement. Your task is to design an algorithm that efficiently analyzes this data and provides meaningful insights.

Problem Description

You are given a list of students and their corresponding examination scores. Each student is represented by a name (string) and a score (integer). Your goal is to write an algorithm that calculates the following:

1. Class Average: The average score of all students in the class.
2. Students Below Average: A list of student names who scored below the class average.
3. Score Distribution: A dictionary (or similar data structure) representing the distribution of scores. The keys should be the scores, and the values should be the number of students who achieved that score.

The algorithm should handle edge cases such as an empty list of students, and should be efficient in processing a potentially large number of students.

Examples

Example 1:

Input: [("Alice", 85), ("Bob", 72), ("Charlie", 90), ("David", 68), ("Eve", 78)]
Output:
    Class Average: 79.6
    Students Below Average: ["Bob", "David"]
    Score Distribution: {68: 1, 72: 1, 78: 1, 85: 1, 90: 1}
Explanation: The class average is calculated as (85 + 72 + 90 + 68 + 78) / 5 = 79.6. Bob (72) and David (68) scored below this average. Each score appears once in the distribution.

Example 2:

Input: [("Alice", 90), ("Bob", 90), ("Charlie", 90)]
Output:
    Class Average: 90.0
    Students Below Average: []
    Score Distribution: {90: 3}
Explanation: The class average is 90. No students scored below 90. The score 90 appears three times.

Example 3: (Edge Case)

Input: []
Output:
    Class Average: 0.0
    Students Below Average: []
    Score Distribution: {}
Explanation: With no students, the class average is 0, there are no students below average, and the score distribution is empty.

Constraints

• The number of students can range from 0 to 10,000.
• Student names are strings with lengths between 1 and 50 characters.
• Examination scores are integers between 0 and 100 (inclusive).
• The algorithm should have a time complexity of O(n), where n is the number of students. Avoid nested loops that would increase complexity.
• Input will always be a list of tuples, where each tuple contains a student's name (string) and score (integer).

Notes

• Consider using appropriate data structures (e.g., dictionaries, lists) to efficiently store and process the data.
• When calculating the class average, handle the case of an empty list of students gracefully (e.g., return 0).
• The order of students in the "Students Below Average" list does not matter.
• The score distribution should accurately reflect the frequency of each score.
• Focus on clarity and readability in your pseudocode. Assume basic arithmetic operations are available.
• Think about how to efficiently calculate the average and identify students below average in a single pass through the data.

Pseudocode:

FUNCTION analyze_exams(student_data):
  // student_data is a list of tuples: [(student_name, score), ...]

  total_score = 0
  num_students = LENGTH(student_data)
  score_distribution = {}
  below_average_students = []

  // Calculate total score and populate score distribution
  FOR EACH (student_name, score) IN student_data:
    total_score = total_score + score

    // Update score distribution
    IF score IS IN score_distribution:
      score_distribution[score] = score_distribution[score] + 1
    ELSE:
      score_distribution[score] = 1

  // Calculate class average
  IF num_students > 0:
    class_average = total_score / num_students
  ELSE:
    class_average = 0.0

  // Identify students below average
  FOR EACH (student_name, score) IN student_data:
    IF score < class_average:
      below_average_students.APPEND(student_name)

  // Return results
  RETURN {
    "Class Average": class_average,
    "Students Below Average": below_average_students,
    "Score Distribution": score_distribution
  }