Rabbits in Forest - Practice Coding Problems

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

Understanding the Visualization

Input

Array of rabbit answers about same-color count

Process

Group same answers and calculate minimum rabbits

Output

Minimum total rabbits in forest

Key Takeaway

🎯 Key Insight: Rabbits giving the same answer can be optimally grouped using frequency counting and ceiling division

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

Approach	Time	Space	Notes
✓ Brute Force - Individual Counting	O(n)	O(1)	Count each rabbit answer separately without optimization
Frequency Count with Math Optimization	O(n)	O(n)	Count frequency of each answer and calculate minimum groups needed

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>

int solution(int* answers, int size) {
    int total = 0;
    for (int i = 0; i < size; i++) {
        total += answers[i] + 1;
    }
    return total;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    int answers[1000];
    int size = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        answers[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    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