Customers Who Bought All Products solution and explanation

# For illustrative purposes as Python would need a cursor from a DB connection
query = """
SELECT customer_id
FROM Customer
GROUP BY customer_id
HAVING COUNT(DISTINCT product_key) = (SELECT COUNT(*) FROM Product)
"""

// Not directly executable Java, but SQL logic can be prepared in Java context like this
String query = "
SELECT customer_id
FROM Customer
GROUP BY customer_id
HAVING COUNT(DISTINCT product_key) = (SELECT COUNT(*) FROM Product)
";

// C++ doesn't natively handle SQL, so this pseudocode outlines the logic.
std::string query = "
SELECT customer_id
FROM Customer
GROUP BY customer_id
HAVING COUNT(DISTINCT product_key) = (SELECT COUNT(*) FROM Product)
";

// JavaScript would rely on SQL directly accessed through a client or like node-sql
const query = `
SELECT customer_id
FROM Customer
GROUP BY customer_id
HAVING COUNT(DISTINCT product_key) = (SELECT COUNT(*) FROM Product)
`;

// Since this is more about using SQL, we can't directly implement this in C.
// Here we showcase how it can be structured logically in SQL.
char* query = "
SELECT customer_id
FROM Customer
GROUP BY customer_id
HAVING COUNT(DISTINCT product_key) = (SELECT COUNT(*) FROM Product)
";

// Not directly executable in C#, but encapsulating SQL syntax for database access
string query = "
SELECT customer_id
FROM Customer
GROUP BY customer_id
HAVING COUNT(DISTINCT product_key) = (SELECT COUNT(*) FROM Product)
";

def customers_who_bought_all_products(customer_data, product_count):
    from collections import defaultdict
    customer_products = defaultdict(set)

    for customer_id, product_key in customer_data:
        customer_products[customer_id].add(product_key)

    all_product_customers = [
        customer_id
        for customer_id, products in customer_products.items()
        if len(products) == product_count
    ]

    return all_product_customers

# Example execution
customer_data = [(1, 5), (2, 6), (3, 5), (3, 6), (1, 6)]
product_count = 2  # Total distinct products
print(customers_who_bought_all_products(customer_data, product_count))  # Outputs: [1, 3]

import java.util.*;

public class Solution {
    public static List<Integer> customersWhoBoughtAllProducts(int[][] customerData, int totalProducts) {
        Map<Integer, Set<Integer>> customerMap = new HashMap<>();

        for (int[] data : customerData) {
            int customerId = data[0];
            int productKey = data[1];
            customerMap.computeIfAbsent(customerId, k -> new HashSet<>()).add(productKey);
        }

        List<Integer> result = new ArrayList<>();
        for (Map.Entry<Integer, Set<Integer>> entry : customerMap.entrySet()) {
            if (entry.getValue().size() == totalProducts) {
                result.add(entry.getKey());
            }
        }
        return result;
    }

    public static void main(String[] args) {
        int[][] customerData = {{1, 5}, {2, 6}, {3, 5}, {3, 6}, {1, 6}};
        int totalProducts = 2;  // Total distinct products
        System.out.println(customersWhoBoughtAllProducts(customerData, totalProducts));  // Outputs: [1, 3]
    }
}

#include <iostream>
#include <unordered_map>
#include <unordered_set>
#include <vector>

std::vector<int> customersWhoBoughtAllProducts(const std::vector<std::pair<int, int>>& customerData, int totalProducts) {
    std::unordered_map<int, std::unordered_set<int>> customerMap;

    for (const auto& [customerId, productKey] : customerData) {
        customerMap[customerId].insert(productKey);
    }

    std::vector<int> result;
    for (const auto& [customerId, products] : customerMap) {
        if (products.size() == totalProducts) {
            result.push_back(customerId);
        }
    }

    return result;
}

int main() {
    std::vector<std::pair<int, int>> customerData = { {1, 5}, {2, 6}, {3, 5}, {3, 6}, {1, 6} };
    int totalProducts = 2;  // Total distinct products
    std::vector<int> result = customersWhoBoughtAllProducts(customerData, totalProducts);
    for (int id : result) {
        std::cout << id << " ";  // Outputs: 1 3
    }
    return 0;
}

function customersWhoBoughtAllProducts(customerData, totalProducts) {
    const customerMap = new Map();

    customerData.forEach(([customerId, productKey]) => {
        if (!customerMap.has(customerId)) {
            customerMap.set(customerId, new Set());
        }
        customerMap.get(customerId).add(productKey);
    });

    return [...customerMap.entries()].filter(
        ([, productSet]) => productSet.size === totalProducts
    ).map(([customerId, ]) => customerId);
}

// Example execution
const customerData = [[1, 5], [2, 6], [3, 5], [3, 6], [1, 6]];
const totalProducts = 2;  // Total distinct products
console.log(customersWhoBoughtAllProducts(customerData, totalProducts));  // Outputs: [1, 3]

using System;
using System.Collections.Generic;

public class Solution {
    public static List<int> CustomersWhoBoughtAllProducts(int[][] customerData, int totalProducts) {
        Dictionary<int, HashSet<int>> customerMap = new Dictionary<int, HashSet<int>>();

        foreach (var data in customerData) {
            int customerId = data[0];
            int productKey = data[1];
            if (!customerMap.ContainsKey(customerId)) {
                customerMap[customerId] = new HashSet<int>();
            }
            customerMap[customerId].Add(productKey);
        }

        List<int> result = new List<int>();
        foreach (var entry in customerMap) {
            if (entry.Value.Count == totalProducts) {
                result.Add(entry.Key);
            }
        }

        return result;
    }

    public static void Main() {
        int[][] customerData = new int[][] {
            new int[] { 1, 5 }, new int[] { 2, 6 }, new int[] { 3, 5 },
            new int[] { 3, 6 }, new int[] { 1, 6 }
        };
        int totalProducts = 2;  // Total distinct products
        Console.WriteLine(String.Join(", ", CustomersWhoBoughtAllProducts(customerData, totalProducts)));  // Outputs: 1, 3
    }
}

# Write your MySQL query statement below
SELECT customer_id
FROM Customer
GROUP BY 1
HAVING COUNT(DISTINCT product_key) = (SELECT COUNT(1) FROM Product);