Rabbits in Forest

Rabbits in Forest - Problem

There is a forest with an unknown number of rabbits. We asked n rabbits "How many rabbits have the same color as you?" and collected the answers in an integer array answers where answers[i] is the answer of the ith rabbit.

Given the array answers, return the minimum number of rabbits that could be in the forest.

Input & Output

Example 1 — Basic Grouping

$ Input: answers = [1,1,2]

› Output: 5

💡 Note: Two rabbits answered 1, so they can form one group of 2 rabbits with same color. One rabbit answered 2, so it needs a group of 3 rabbits. Total: 2 + 3 = 5 rabbits minimum.

Example 2 — Multiple Groups

$ Input: answers = [10,10,10]

› Output: 11

💡 Note: Three rabbits answered 10, meaning each claims there are 11 rabbits of its color (including itself). Since we have 3 such answers, they can all belong to the same group of 11 rabbits.

Example 3 — Single Rabbit

$ Input: answers = [1]

› Output: 2

💡 Note: One rabbit answered 1, meaning there should be 2 rabbits of its color total (including itself).

Constraints

1 ≤ answers.length ≤ 1000
0 ≤ answers[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 f Facebook 15

The key insight is that rabbits with the same answer can be grouped together optimally. Use frequency counting with ceiling division to determine minimum groups needed. Best approach is frequency count with math. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force - Individual Counting

⏱️ Time: O(n) Space: O(1)

For each answer, assume it represents a separate group and count all possible rabbits. This doesn't consider that multiple rabbits with the same answer could belong to the same color group.

Frequency Count with Math Optimization

⏱️ Time: O(n) Space: O(n)

Use a hash map to count how many rabbits gave each answer, then for each unique answer, calculate the minimum number of color groups needed using ceiling division.

Brute Force - Individual Counting — Algorithm Steps

Iterate through each answer
For each answer k, add k+1 rabbits to total
Return the sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Each Answer

Add answer + 1 for each rabbit

Sum All Counts

Total all individual counts

Result

Non-optimal total count

Code -

solution.c — C

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

static int count[1001]; // count[i] = frequency of answer i

int solution(int* answers, int size) {
    if (size == 0) return 0;
    
    // Reset count array
    memset(count, 0, sizeof(count));
    
    // Count frequencies
    for (int i = 0; i < size; i++) {
        count[answers[i]]++;
    }
    
    int total = 0;
    for (int answer = 0; answer <= 1000; answer++) {
        if (count[answer] > 0) {
            int freq = count[answer];
            int groupSize = answer + 1;
            int numGroups = (freq + groupSize - 1) / groupSize; // ceiling division
            total += numGroups * groupSize;
        }
    }
    
    return total;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Handle empty array
    if (strstr(line, "[]") != NULL) {
        printf("0\n");
        return 0;
    }
    
    static int answers[1000];
    int size = 0;
    
    // Parse array using strtol
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        answers[size++] = (int)strtol(p, &p, 10);
    }
    
    printf("%d\n", solution(answers, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop through all answers

✓ Linear Growth

Space Complexity

O(1)

Only uses a counter variable

✓ Linear Space

28.5K 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

Brute Force - Individual Counting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler