Rabbits in Forest solution and explanation

from collections import Counter

def min_number_of_rabbits(answers):
    counter = Counter(answers)
    rabbits_count = 0
    for answer, count in counter.items():
        group_size = answer + 1
        group_count = (count + group_size - 1) // group_size
        rabbits_count += group_count * group_size
    return rabbits_count

# Example usage
answers = [1, 1, 2]
print(min_number_of_rabbits(answers))  # Output: 5

#include <vector>
#include <unordered_map>
#include <cmath>

int minNumberOfRabbits(std::vector<int>& answers) {
    std::unordered_map<int, int> countMap;
    for (int answer : answers) {
        countMap[answer]++;
    }

    int totalRabbits = 0;
    for (auto& [answer, count] : countMap) {
        int groupSize = answer + 1;
        int groupCount = std::ceil(count / static_cast<double>(groupSize));
        totalRabbits += groupCount * groupSize;
    }
    return totalRabbits;
}

// Example usage
// int result = minNumberOfRabbits(answers);

import java.util.HashMap;

public class MinRabbits {
    public int minNumberOfRabbits(int[] answers) {
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int ans : answers) {
            map.put(ans, map.getOrDefault(ans, 0) + 1);
        }

        int totalRabbits = 0;
        for (int key : map.keySet()) {
            int groupSize = key + 1;
            int count = map.get(key);
            int groupCount = (count + groupSize - 1) / groupSize;
            totalRabbits += groupCount * groupSize;
        }

        return totalRabbits;
    }

    // Example usage
    // int result = new MinRabbits().minNumberOfRabbits(new int[]{1, 1, 2});
}

function minNumberOfRabbits(answers) {
    const countMap = new Map();
    answers.forEach(answer => {
        countMap.set(answer, (countMap.get(answer) || 0) + 1);
    });
    let totalRabbits = 0;
    countMap.forEach((count, answer) => {
        const groupSize = answer + 1;
        const groupCount = Math.ceil(count / groupSize);
        totalRabbits += groupCount * groupSize;
    });
    return totalRabbits;
}

// Example usage
console.log(minNumberOfRabbits([1, 1, 2])); // Output: 5

function numRabbits(answers: number[]): number {
    const cnt = new Map<number, number>();
    for (const x of answers) {
        cnt.set(x, (cnt.get(x) || 0) + 1);
    }
    let ans = 0;
    for (const [x, v] of cnt.entries()) {
        const group = x + 1;
        ans += Math.floor((v + group - 1) / group) * group;
    }
    return ans;
}

func numRabbits(answers []int) (ans int) {
	cnt := map[int]int{}
	for _, x := range answers {
		cnt[x]++
	}
	for x, v := range cnt {
		group := x + 1
		ans += (v + group - 1) / group * group
	}
	return
}