Rabbits in Forest - Practice Coding Problems

Rabbits in Forest - Problem

Imagine you're a wildlife researcher conducting a survey in a mysterious forest. You've encountered n rabbits and asked each one a simple question: "How many other rabbits have the same color fur as you?"

The rabbits are quite cooperative and provide their answers in an array called answers, where answers[i] represents the i-th rabbit's response.

Here's the key insight: if a rabbit says there are k other rabbits with the same color, then there are actually k + 1 rabbits of that color in total (including the rabbit answering).

Your goal: Determine the minimum possible number of rabbits that could exist in the forest based on these answers.

Example: If two rabbits both say "1" (meaning each sees 1 other rabbit of their color), they could be referring to each other, so we need minimum 2 rabbits total, not 4.

Input & Output

example_1.py — Basic Case

$ Input: [1, 1, 2]

› Output: 5

💡 Note: Two rabbits answer "1" (meaning each sees 1 other of their color) - they can form one group of 2. One rabbit answers "2" (meaning it sees 2 others of its color) - this requires a group of 3. Total: 2 + 3 = 5 rabbits minimum.

example_2.py — Multiple Same Answers

$ Input: [10, 10, 10]

› Output: 11

💡 Note: Three rabbits all answer "10" (each sees 10 others of their color). Since each color group has 11 rabbits total, and we have only 3 rabbits giving this answer, they can all belong to the same group of 11. Minimum: 11 rabbits.

example_3.py — Edge Case

$ Input: []

› Output: 0

💡 Note: No rabbits were surveyed, so the minimum number of rabbits in the forest is 0.

Constraints

1 ≤ answers.length ≤ 1000
0 ≤ answers[i] ≤ 999
Each rabbit gives one honest answer about others of their color

Visualization

Tap to expand

Understanding the Visualization

Listen to Claims

Each rabbit tells you how many others share their color

Group Optimally

Rabbits with same answer can potentially belong to same color group

Calculate Minimum

Use ceiling division to find minimum groups needed per answer

Key Takeaway

🎯 Key Insight: Group rabbits with same answers optimally using ceil(frequency/(answer+1)) to minimize total count

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 f Meta 8

The optimal solution uses hash table frequency counting with mathematical insight. Key idea: if k rabbits claim answer n, we need ceil(k/(n+1)) complete groups, each contributing (n+1) rabbits. Time: O(n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(n)	Count frequency of each answer and calculate minimum rabbits needed per color group
Brute Force (Simulation)	O(k^n)	O(n)	Try all possible rabbit groupings and find minimum valid configuration

One-Pass Hash Table (Optimal) — Algorithm Steps

Count frequency of each answer using hash table
For each unique answer k with frequency f, calculate groups needed: ceil(f / (k+1))
Each group contributes (k+1) rabbits to total
Sum up rabbits from all groups

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Build hash table with answer frequencies

Calculate Groups

For each answer k, determine ceil(frequency / (k+1)) groups

Sum Rabbits

Each group contributes (k+1) rabbits to total

Code -

solution.c — C

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

#define MAX_ANSWERS 1000

int numRabbitsInForest(int* answers, int answersSize) {
    if (answersSize == 0) return 0;
    
    // Count frequency using array (assuming answers are small)
    int count[MAX_ANSWERS] = {0};
    int maxAnswer = 0;
    
    for (int i = 0; i < answersSize; i++) {
        count[answers[i]]++;
        if (answers[i] > maxAnswer) {
            maxAnswer = answers[i];
        }
    }
    
    int totalRabbits = 0;
    
    // Calculate minimum rabbits for each answer group
    for (int answer = 0; answer <= maxAnswer; answer++) {
        if (count[answer] > 0) {
            int freq = count[answer];
            int groupSize = answer + 1;
            int groupsNeeded = (freq + groupSize - 1) / groupSize; // Ceiling division
            totalRabbits += groupsNeeded * groupSize;
        }
    }
    
    return totalRabbits;
}

int main() {
    int answers[] = {1, 1, 2};
    int size = sizeof(answers) / sizeof(answers[0]);
    printf("%d\n", numRabbitsInForest(answers, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count frequencies plus iteration over unique answers (at most n)

✓ Linear Growth

Space Complexity

O(n)

Hash table stores at most n unique answer values

⚡ Linearithmic Space

31.3K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler