Find the Celebrity - Practice Coding Problems

Find the Celebrity - Problem

Imagine you're at an exclusive party with n people labeled from 0 to n-1. Among these party-goers, there might be exactly one celebrity!

A celebrity has a very specific definition:

🌟 Everyone knows the celebrity (all other n-1 people)
🙈 The celebrity knows nobody (not a single person at the party)

Your mission is to find this celebrity using the minimum number of questions possible. You can only ask questions in the format: "Hi A, do you know B?"

You have access to a helper function knows(a, b) that returns true if person a knows person b, and false otherwise.

Goal: Return the celebrity's label if one exists, or -1 if there's no celebrity at the party.

Challenge: Can you solve this in less than O(n²) questions?

Input & Output

example_1.py — Basic Celebrity Case

$ Input: n = 3, graph = [[1,1,0],[0,1,0],[1,1,1]]

› Output: 1

💡 Note: Person 1 is the celebrity because everyone (0,2) knows person 1, but person 1 doesn't know anyone (knows(1,0)=false, knows(1,2)=false).

example_2.py — No Celebrity

$ Input: n = 2, graph = [[1,1],[1,1]]

› Output: -1

💡 Note: There's no celebrity because both people know each other. A celebrity should know nobody.

example_3.py — Single Person

$ Input: n = 1, graph = [[1]]

› Output: 0

💡 Note: Person 0 is automatically the celebrity since there's only one person at the party.

Visualization

Tap to expand

Understanding the Visualization

Tournament Bracket

Start with all people as potential celebrities

Head-to-Head Matches

Ask: 'Does person A know person B?'

Elimination Rules

If A knows B → A is eliminated. If A doesn't know B → B is eliminated

Final Candidate

The last remaining person is our celebrity candidate

Championship Verification

Verify the candidate actually deserves the celebrity title

Key Takeaway

🎯 Key Insight: Each elimination question removes exactly one person from consideration, making this approach optimal with just O(n) questions total!

Time & Space Complexity

Time Complexity

⏱️

O(n)

n-1 questions for elimination phase + 2(n-1) questions for verification = 3n-3 total questions

✓ Linear Growth

Space Complexity

O(1)

Only using two pointers and a few variables for tracking

✓ Linear Space

Constraints

n == graph.length == graph[i].length
2 ≤ n ≤ 100
graph[i][j] is 0 or 1
graph[i][i] == 1 for all i (everyone knows themselves)
There will be exactly one celebrity in the party if they exist

Asked in

G Google 45 f Facebook 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses a two-pointers elimination strategy to find the celebrity in O(n) time. The key insight is that each question eliminates exactly one person: if person A knows person B, then A cannot be the celebrity; if A doesn't know B, then B cannot be the celebrity. After finding a candidate through elimination, we verify they actually satisfy the celebrity conditions.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers Elimination (Optimal)	O(n)	O(1)	Use two pointers to eliminate one person per question, then verify the final candidate
Brute Force (Check Every Person)	O(n²)	O(1)	Check if each person could be a celebrity by asking about all relationships

Two Pointers Elimination (Optimal) — Algorithm Steps

Initialize two pointers: left = 0, right = n-1
While left < right, ask if knows(left, right)
If left knows right: left cannot be celebrity (increment left)
If left doesn't know right: right cannot be celebrity (decrement right)
After elimination, left == right (our candidate)
Verify the candidate is actually a celebrity

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Setup

Start with left=0, right=n-1 pointers at opposite ends

Ask Question

Ask: Does person at left know person at right?

Eliminate

If yes: eliminate left (move left++). If no: eliminate right (move right--)

Find Candidate

When left==right, we have our potential celebrity

Verify

Check if candidate actually satisfies celebrity conditions

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>

bool knows(int a, int b) {
    // This function is provided by the problem
    return false;
}

int findCelebrity(int n) {
    // Phase 1: Elimination using two pointers
    int left = 0, right = n - 1;
    
    while (left < right) {
        if (knows(left, right)) {
            // left knows right, so left cannot be celebrity
            left++;
        } else {
            // left doesn't know right, so right cannot be celebrity
            right--;
        }
    }
    
    // Phase 2: Verify the candidate
    int candidate = left;
    
    // Check if candidate knows anyone (should not)
    for (int i = 0; i < n; i++) {
        if (i != candidate && knows(candidate, i)) {
            return -1;
        }
    }
    
    // Check if everyone knows candidate (should be true)
    for (int i = 0; i < n; i++) {
        if (i != candidate && !knows(i, candidate)) {
            return -1;
        }
    }
    
    return candidate;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

n-1 questions for elimination phase + 2(n-1) questions for verification = 3n-3 total questions

✓ Linear Growth

Space Complexity

O(1)

Only using two pointers and a few variables for tracking

✓ Linear Space

Constraints

n == graph.length == graph[i].length
2 ≤ n ≤ 100
graph[i][j] is 0 or 1
graph[i][i] == 1 for all i (everyone knows themselves)
There will be exactly one celebrity in the party if they exist

43.3K Views

Medium-High Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers Elimination (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler