Sum of Elements With Frequency Divisible by K

// Accepted solution for LeetCode #3712: Sum of Elements With Frequency Divisible by K
class Solution {
    public int sumDivisibleByK(int[] nums, int k) {
        Map<Integer, Integer> cnt = new HashMap<>();
        for (int x : nums) {
            cnt.merge(x, 1, Integer::sum);
        }
        int ans = 0;
        for (var e : cnt.entrySet()) {
            int x = e.getKey(), v = e.getValue();
            if (v % k == 0) {
                ans += x * v;
            }
        }
        return ans;
    }
}

// Accepted solution for LeetCode #3712: Sum of Elements With Frequency Divisible by K
func sumDivisibleByK(nums []int, k int) (ans int) {
	cnt := map[int]int{}
	for _, x := range nums {
		cnt[x]++
	}
	for x, v := range cnt {
		if v%k == 0 {
			ans += x * v
		}
	}
	return
}

# Accepted solution for LeetCode #3712: Sum of Elements With Frequency Divisible by K
class Solution:
    def sumDivisibleByK(self, nums: List[int], k: int) -> int:
        cnt = Counter(nums)
        return sum(x * v for x, v in cnt.items() if v % k == 0)

// Accepted solution for LeetCode #3712: Sum of Elements With Frequency Divisible by K
fn sum_divisible_by_k(nums: Vec<i32>, k: i32) -> i32 {
    nums.into_iter()
        .fold(std::collections::HashMap::new(), |mut acc, n| {
            *acc.entry(n).or_insert(0) += 1;
            acc
        })
        .into_iter()
        .fold(
            0,
            |acc, (n, v)| {
                if v % k == 0 {
                    acc + (n * v)
                } else {
                    acc
                }
            },
        )
}

fn main() {
    let nums = vec![1, 2, 2, 3, 3, 3, 3, 4];
    let ret = sum_divisible_by_k(nums, 2);
    println!("ret={ret}");
}

#[test]
fn test() {
    {
        let nums = vec![1, 2, 2, 3, 3, 3, 3, 4];
        let ret = sum_divisible_by_k(nums, 2);
        assert_eq!(ret, 16);
    }
    {
        let nums = vec![1, 2, 3, 4, 5];
        let ret = sum_divisible_by_k(nums, 2);
        assert_eq!(ret, 0);
    }
    {
        let nums = vec![4, 4, 4, 1, 2, 3];
        let ret = sum_divisible_by_k(nums, 3);
        assert_eq!(ret, 12);
    }
}

// Accepted solution for LeetCode #3712: Sum of Elements With Frequency Divisible by K
function sumDivisibleByK(nums: number[], k: number): number {
    const cnt = new Map();
    for (const x of nums) {
        cnt.set(x, (cnt.get(x) || 0) + 1);
    }
    let ans = 0;
    for (const [x, v] of cnt.entries()) {
        if (v % k === 0) {
            ans += x * v;
        }
    }
    return ans;
}