Number of Unique Subjects Taught by Each Teacher solution and explanation

# Python solution
from collections import defaultdict

def count_unique_subjects(teacher_records):
    teacher_to_subjects = defaultdict(set)
    for record in teacher_records:
        teacher_id, subject_id, _ = record
        teacher_to_subjects[teacher_id].add(subject_id)
    
    result = []
    for teacher_id, subjects in teacher_to_subjects.items():
        result.append((teacher_id, len(subjects)))
    return result

# Example input
teacher_records = [
    (1, 2, 3),
    (1, 2, 4),
    (1, 3, 3),
    (2, 1, 1),
    (2, 2, 1),
    (2, 3, 1),
    (2, 4, 1)
]

# Function call
print(count_unique_subjects(teacher_records))

// JavaScript solution
function countUniqueSubjects(teacherRecords) {
    const teacherToSubjects = {};
    teacherRecords.forEach(([teacherId, subjectId]) => {
        if (!teacherToSubjects[teacherId]) {
            teacherToSubjects[teacherId] = new Set();
        }
        teacherToSubjects[teacherId].add(subjectId);
    });

    const result = [];
    for (const [teacherId, subjects] of Object.entries(teacherToSubjects)) {
        result.push({ teacher_id: +teacherId, cnt: subjects.size });
    }
    return result;
}

// Example input
const teacherRecords = [
    [1, 2, 3],
    [1, 2, 4],
    [1, 3, 3],
    [2, 1, 1],
    [2, 2, 1],
    [2, 3, 1],
    [2, 4, 1]
];

// Function call
console.log(countUniqueSubjects(teacherRecords));

// Java solution
import java.util.*;

public class UniqueSubjects {
    public static List<int[]> countUniqueSubjects(int[][] teacherRecords) {
        Map<Integer, Set<Integer>> teacherToSubjects = new HashMap<>();

        for (int[] record : teacherRecords) {
            int teacherId = record[0];
            int subjectId = record[1];
            teacherToSubjects
                .computeIfAbsent(teacherId, k -> new HashSet<>())
                .add(subjectId);
        }

        List<int[]> result = new ArrayList<>();
        for (Map.Entry<Integer, Set<Integer>> entry : teacherToSubjects.entrySet()) {
            result.add(new int[] {entry.getKey(), entry.getValue().size()});
        }
        return result;
    }

    // Example usage
    public static void main(String[] args) {
        int[][] teacherRecords = {
            {1, 2, 3},
            {1, 2, 4},
            {1, 3, 3},
            {2, 1, 1},
            {2, 2, 1},
            {2, 3, 1},
            {2, 4, 1}
        };
        List<int[]> results = countUniqueSubjects(teacherRecords);
        for (int[] r : results) {
            System.out.println("Teacher " + r[0] + " teaches " + r[1] + " unique subjects");
        }
    }
}

// C++ solution
#include <iostream>
#include <vector>
#include <unordered_map>
#include <unordered_set>

std::vector<std::pair<int, int>> countUniqueSubjects(const std::vector<std::tuple<int, int, int>>& teacherRecords) {
    std::unordered_map<int, std::unordered_set<int>> teacherToSubjects;

    for (const auto& record : teacherRecords) {
        int teacherId = std::get<0>(record);
        int subjectId = std::get<1>(record);
        teacherToSubjects[teacherId].insert(subjectId);
    }

    std::vector<std::pair<int, int>> result;
    for (const auto& entry : teacherToSubjects) {
        result.emplace_back(entry.first, entry.second.size());
    }
    return result;
}

int main() {
    std::vector<std::tuple<int, int, int>> teacherRecords = {
        {1, 2, 3},
        {1, 2, 4},
        {1, 3, 3},
        {2, 1, 1},
        {2, 2, 1},
        {2, 3, 1},
        {2, 4, 1}
    };

    auto results = countUniqueSubjects(teacherRecords);
    for (const auto& result : results) {
        std::cout << "Teacher " << result.first << " teaches " << result.second << " unique subjects\n";
    }
    return 0;
}

# Write your MySQL query statement below
SELECT teacher_id, COUNT(DISTINCT subject_id) AS cnt
FROM Teacher
GROUP BY 1;