Actors and Directors Who Cooperated At Least Three Times solution and explanation

from collections import defaultdict

def find_pairs(actor_director):
    pair_count = defaultdict(int)
    for pair in actor_director:
        pair_count[(pair[0], pair[1])] += 1
    
    print('+-------------+-------------+')
    print('| actor_id    | director_id |')
    print('+-------------+-------------+')
    for pair, count in pair_count.items():
        if count >= 3:
            print(f'| {pair[0]:11} | {pair[1]:11} |')

pairs = [
    (1, 1), (1, 1), (1, 1),
    (1, 2), (1, 2),
    (2, 1), (2, 1)
]

find_pairs(pairs)

import java.util.*;

public class Solution {
    public static void main(String[] args) {
        int[][] actorDirector = {
            {1, 1}, {1, 1}, {1, 1},
            {1, 2}, {1, 2},
            {2, 1}, {2, 1}
        };
    
        Map<List<Integer>, Integer> pairCount = new HashMap<>();
        for (int[] pair : actorDirector) {
            List<Integer> list = Arrays.asList(pair[0], pair[1]);
            pairCount.put(list, pairCount.getOrDefault(list, 0) + 1);
        }

        System.out.println("+-------------+-------------+");
        System.out.println("| actor_id    | director_id |");
        System.out.println("+-------------+-------------+");
        for (Map.Entry<List<Integer>, Integer> entry : pairCount.entrySet()) {
            if (entry.getValue() >= 3) {
                System.out.printf("| %11d | %11d |\n", entry.getKey().get(0), entry.getKey().get(1));
            }
        }
    }
}

#include <iostream>
#include <unordered_map>
#include <utility>

using namespace std;

typedef pair<int, int> Pair;

int main() {
    unordered_map<Pair, int, hash<Pair>> pairCount;
    Pair pairs[] = {
        {1, 1}, {1, 1}, {1, 1},
        {1, 2}, {1, 2},
        {2, 1}, {2, 1}
    };
    int size = sizeof(pairs) / sizeof(pairs[0]);
    for (int i = 0; i < size; ++i) {
        pairCount[pairs[i]]++;
    }
    cout << "+-------------+-------------+\n";
    cout << "| actor_id    | director_id |\n";
    cout << "+-------------+-------------+\n";
    for (auto &entry : pairCount) {
        if (entry.second >= 3)
            cout << "| " << entry.first.first << "           | " << entry.first.second << "           |\n";
    }
    return 0;
}

const pairs = [
    [1, 1], [1, 1], [1, 1],
    [1, 2], [1, 2],
    [2, 1], [2, 1]
];

const pairCount = new Map();
pairs.forEach(([actorId, directorId]) => {
    const key = `${actorId},${directorId}`;
    pairCount.set(key, (pairCount.get(key) || 0) + 1);
});

console.log('+-------------+-------------+');
console.log('| actor_id    | director_id |');
console.log('+-------------+-------------+');
pairCount.forEach((count, key) => {
    if (count >= 3) {
        const [actorId, directorId] = key.split(',').map(Number);
        console.log(`| ${actorId.toString().padStart(11)} | ${directorId.toString().padStart(11)} |`);
    }
});

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define TABLE_SIZE 1000

typedef struct Pair {
    int actor_id;
    int director_id;
} Pair;

typedef struct Node {
    Pair pair;
    int count;
    struct Node* next;
} Node;

Node* hashMap[TABLE_SIZE] = {NULL};

unsigned int hash(Pair pair) {
    return (pair.actor_id * 31 + pair.director_id) % TABLE_SIZE;
}

void insertOrIncrement(Pair pair) {
    unsigned int index = hash(pair);
    Node* node = hashMap[index];
    while (node != NULL) {
        if (node->pair.actor_id == pair.actor_id && node->pair.director_id == pair.director_id) {
            node->count++;
            return;
        }
        node = node->next;
    }
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->pair = pair;
    newNode->count = 1;
    newNode->next = hashMap[index];
    hashMap[index] = newNode;
}

void findPairs(Pair* pairs, int size) {
    for (int i = 0; i < size; ++i) {
        insertOrIncrement(pairs[i]);
    }
    printf("+-------------+-------------+\n");
    printf("| actor_id    | director_id |\n");
    printf("+-------------+-------------+\n");
    for (int i = 0; i < TABLE_SIZE; ++i) {
        Node* node = hashMap[i];
        while (node != NULL) {
            if (node->count >= 3) {
                printf("| %11d | %11d |\n", node->pair.actor_id, node->pair.director_id);
            }
            node = node->next;
        }
    }
}

int main() {
    Pair pairs[] = {
        {1, 1}, {1, 1}, {1, 1},
        {1, 2}, {1, 2},
        {2, 1}, {2, 1}
    };
    int size = sizeof(pairs) / sizeof(pairs[0]);
    findPairs(pairs, size);
    return 0;
}

using System;
using System.Collections.Generic;

public class Solution {
    public static void Main(string[] args) {
        int[,] pairs = new int[,] {
            {1, 1}, {1, 1}, {1, 1},
            {1, 2}, {1, 2},
            {2, 1}, {2, 1}
        };

        Dictionary<(int, int), int> pairCount = new Dictionary<(int, int), int>();
        for (int i = 0; i < pairs.GetLength(0); i++) {
            var actorDirector = (pairs[i, 0], pairs[i, 1]);
            if (pairCount.ContainsKey(actorDirector)) {
                pairCount[actorDirector]++;
            } else {
                pairCount[actorDirector] = 1;
            }
        }

        Console.WriteLine("+-------------+-------------+");
        Console.WriteLine("| actor_id    | director_id |");
        Console.WriteLine("+-------------+-------------+");
        foreach (var entry in pairCount) {
            if (entry.Value >= 3) {
                Console.WriteLine($"| {entry.Key.Item1,11} | {entry.Key.Item2,11} |");
            }
        }
    }
}

SELECT actor_id, director_id
FROM ActorDirector
GROUP BY actor_id, director_id
HAVING COUNT(*) >= 3;