Count Collisions of Monkeys on a Polygon - Practice Coding Problems

Count Collisions of Monkeys on a Polygon - Problem

Math Recursion Medium

Imagine a regular convex polygon with n vertices, where each vertex is labeled from 0 to n-1 in clockwise order. At each vertex sits exactly one monkey, creating a perfect circle of our primate friends!

The Challenge: All monkeys simultaneously decide to move to a neighboring vertex (either clockwise or counterclockwise). A collision occurs when:

Two or more monkeys end up on the same vertex after moving
Two monkeys cross paths while moving along the same edge

Your Mission: Calculate how many different ways the monkeys can move such that at least one collision happens. Since this number can be astronomically large, return the result modulo 10⁹ + 7.

Key Insight: This is actually a clever math problem in disguise! Think about when collisions DON'T happen, then subtract from the total possibilities.

Input & Output

example_1.py — Basic Triangle

$ Input: n = 3

› Output: 6

💡 Note: With 3 monkeys on a triangle, total movements = 2³ = 8. Only 2 movements avoid collisions: all clockwise or all counterclockwise. Therefore, collision movements = 8 - 2 = 6.

example_2.py — Square Formation

$ Input: n = 4

› Output: 14

💡 Note: With 4 monkeys on a square, total movements = 2⁴ = 16. Only 2 movements avoid collisions (all same direction). Therefore, collision movements = 16 - 2 = 14.

example_3.py — Minimal Case

$ Input: n = 2

› Output: 2

💡 Note: With 2 monkeys on a line (degenerate polygon), total movements = 2² = 4. Collision-free movements = 2 (both clockwise or both counterclockwise). Answer = 4 - 2 = 2.

Constraints

3 ≤ n ≤ 10⁹
Large input range requires efficient O(log n) solution
Result must be returned modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Setup the Stage

n monkeys on n vertices of a regular polygon, each must move to adjacent vertex

Count Total Possibilities

Each monkey has 2 choices (clockwise/counterclockwise) = 2^n total combinations

Identify Harmony

Only 2 ways avoid collisions: ALL move clockwise OR ALL move counterclockwise

Calculate Chaos

Collision scenarios = Total possibilities - Harmony scenarios = 2^n - 2

Key Takeaway

🎯 Key Insight: In a world of 2^n possibilities, only 2 represent perfect harmony - everyone moving together!

Asked in

G Google 45 a Amazon 32 f Meta 28 ⊞ Microsoft 24 Apple 18

The optimal solution uses the complement principle: calculate 2ⁿ - 2 using fast exponentiation. Out of 2ⁿ total movements, only 2 avoid collisions (all monkeys move in the same direction). Time complexity: O(log n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Combinations)	O(n * 2^n)	O(2^n)	Generate all 2^n possible movements and count collisions
Mathematical Approach (Optimal)	O(log n)	O(1)	Use complement principle: Total ways minus collision-free ways

Brute Force (Generate All Combinations) — Algorithm Steps

Generate all possible movement combinations (2^n total)
For each combination, simulate the movement
Check if any two monkeys end up at the same position
Count combinations that result in collisions

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all 2^n possible movement patterns

Simulate Movement

For each pattern, move each monkey to its new position

Check Collisions

Count how many monkeys end up at each position

Count Results

Add to collision count if any position has multiple monkeys

Code -

solution.c — C

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

int monkeyMove(int n) {
    const int MOD = 1000000007;
    int totalWays = 1 << n; // 2^n
    int collisionCount = 0;
    
    // Generate all possible movements
    for (int mask = 0; mask < totalWays; mask++) {
        int positions[n];
        // Simulate movement for each monkey
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) { // Move clockwise
                positions[i] = (i + 1) % n;
            } else { // Move counterclockwise
                positions[i] = (i - 1 + n) % n;
            }
        }
        
        // Check for collisions using a simple array
        int seen[n];
        memset(seen, 0, sizeof(seen));
        int hasCollision = 0;
        
        for (int i = 0; i < n; i++) {
            if (seen[positions[i]]) {
                hasCollision = 1;
                break;
            }
            seen[positions[i]] = 1;
        }
        
        if (hasCollision) {
            collisionCount++;
        }
    }
    
    return collisionCount % MOD;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * 2^n)

2^n combinations, each taking O(n) time to simulate and check

⚠ Quadratic Growth

Space Complexity

O(2^n)

Need to store all possible movement combinations

⚠ Quadratic Space

58.0K Views

Medium Frequency

~15 min Avg. Time

1.5K 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 (Generate All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler