4Sum II solution and explanation

from collections import Counter

def fourSumCount(nums1, nums2, nums3, nums4):
    sum_map = Counter(a + b for a in nums1 for b in nums2)
    return sum(sum_map[-c - d] for c in nums3 for d in nums4)

import java.util.HashMap;
import java.util.Map;

public class FourSumII {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Map<Integer, Integer> map = new HashMap<>();
        int count = 0;
        
        for (int a : nums1) {
            for (int b : nums2) {
                map.put(a + b, map.getOrDefault(a + b, 0) + 1);
            }
        }
        
        for (int c : nums3) {
            for (int d : nums4) {
                count += map.getOrDefault(-(c + d), 0);
            }
        }
        
        return count;
    }
}

#include <unordered_map>
#include <vector>
using namespace std;

int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
    unordered_map<int, int> sumMap;
    int count = 0;
    
    for (int a : nums1) {
        for (int b : nums2) {
            sumMap[a + b]++;
        }
    }
    
    for (int c : nums3) {
        for (int d : nums4) {
            int complement = -(c + d);
            if (sumMap.count(complement)) {
                count += sumMap[complement];
            }
        }
    }
    
    return count;
}

function fourSumCount(nums1, nums2, nums3, nums4) {
    const sumMap = new Map();
    let count = 0;
    
    for (let a of nums1) {
        for (let b of nums2) {
            const sum = a + b;
            sumMap.set(sum, (sumMap.get(sum) || 0) + 1);
        }
    }
    
    for (let c of nums3) {
        for (let d of nums4) {
            const complement = -(c + d);
            if (sumMap.has(complement)) {
                count += sumMap.get(complement);
            }
        }
    }
    
    return count;
}

#include <stdlib.h>

typedef struct {
    int key;
    int value;
    UT_hash_handle hh;
} HashMapItem;

int fourSumCount(int* nums1, int nums1Size, int* nums2, int nums2Size, int* nums3, int nums3Size, int* nums4, int nums4Size) {
    HashMapItem* hashMap = NULL;
    HashMapItem* item;
    int count = 0;
    
    // Calculating sums of pairs from nums1 and nums2
    for (int i = 0; i < nums1Size; i++) {
        for (int j = 0; j < nums2Size; j++) {
            int sum = nums1[i] + nums2[j];
            HASH_FIND_INT(hashMap, &sum, item);
            if (item == NULL) {
                item = (HashMapItem*)malloc(sizeof(HashMapItem));
                item->key = sum;
                item->value = 1;
                HASH_ADD_INT(hashMap, key, item);
            } else {
                item->value++;
            }
        }
    }
    
    // Calculating sums of pairs from nums3 and nums4
    for (int k = 0; k < nums3Size; k++) {
        for (int l = 0; l < nums4Size; l++) {
            int sum = -(nums3[k] + nums4[l]);
            HASH_FIND_INT(hashMap, &sum, item);
            if (item != NULL) count += item->value;
        }
    }
    
    // Free the hash map
    HASH_CLEAR(hh, hashMap);
    
    return count;
}

using System;
using System.Collections.Generic;

public class Solution {
    public int FourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Dictionary<int, int> sumMap = new Dictionary<int, int>();
        int count = 0;

        foreach (int a in nums1) {
            foreach (int b in nums2) {
                int sum = a + b;
                if (sumMap.ContainsKey(sum)) {
                    sumMap[sum]++;
                } else {
                    sumMap[sum] = 1;
                }
            }
        }

        foreach (int c in nums3) {
            foreach (int d in nums4) {
                int complement = -(c + d);
                if (sumMap.ContainsKey(complement)) {
                    count += sumMap[complement];
                }
            }
        }

        return count;
    }
}

function fourSumCount(nums1: number[], nums2: number[], nums3: number[], nums4: number[]): number {
    const cnt: Record<number, number> = {};
    for (const a of nums1) {
        for (const b of nums2) {
            const x = a + b;
            cnt[x] = (cnt[x] || 0) + 1;
        }
    }
    let ans = 0;
    for (const c of nums3) {
        for (const d of nums4) {
            const x = c + d;
            ans += cnt[-x] || 0;
        }
    }
    return ans;
}

func fourSumCount(nums1 []int, nums2 []int, nums3 []int, nums4 []int) (ans int) {
	cnt := map[int]int{}
	for _, a := range nums1 {
		for _, b := range nums2 {
			cnt[a+b]++
		}
	}
	for _, c := range nums3 {
		for _, d := range nums4 {
			ans += cnt[-(c + d)]
		}
	}
	return
}

use std::collections::HashMap;

impl Solution {
    pub fn four_sum_count(
        nums1: Vec<i32>,
        nums2: Vec<i32>,
        nums3: Vec<i32>,
        nums4: Vec<i32>,
    ) -> i32 {
        let mut cnt = HashMap::new();
        for &a in &nums1 {
            for &b in &nums2 {
                *cnt.entry(a + b).or_insert(0) += 1;
            }
        }
        let mut ans = 0;
        for &c in &nums3 {
            for &d in &nums4 {
                if let Some(&count) = cnt.get(&(0 - (c + d))) {
                    ans += count;
                }
            }
        }
        ans
    }
}