Find the Town Judge - Practice Coding Problems

Find the Town Judge - Problem

In a small town with n people (labeled from 1 to n), there's a rumor about a secret town judge. This mysterious figure has two unique characteristics:

🚫 The judge trusts nobody - they have zero outgoing trust relationships
👥 Everyone trusts the judge - all other (n-1) people trust the judge

You're given a trust array where trust[i] = [a, b] means person a trusts person b. If a trust relationship isn't in the array, it doesn't exist.

Goal: Find and return the label of the town judge. If no such person exists or cannot be uniquely identified, return -1.

Example: With 3 people and trust relationships [[1,3],[2,3]], person 3 is the judge because everyone trusts them (1→3, 2→3) and they trust nobody.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: Person 1 trusts person 2, and person 2 trusts nobody. Since there are only 2 people, person 2 is trusted by everyone else (just person 1) and trusts nobody, making them the judge.

example_2.py — Three People

$ Input: n = 3, trust = [[1,3],[2,3]]

› Output: 3

💡 Note: Person 3 is trusted by both person 1 and person 2, totaling n-1=2 people. Person 3 doesn't trust anyone. Therefore, person 3 is the town judge.

example_3.py — No Judge

$ Input: n = 3, trust = [[1,3],[2,3],[3,1]]

› Output: -1

💡 Note: Person 3 is trusted by persons 1 and 2, but person 3 also trusts person 1. Since the judge cannot trust anyone, there is no town judge.

Constraints

1 ≤ n ≤ 1000
0 ≤ trust.length ≤ 10⁴
trust[i].length == 2
All pairs trust[i] are unique
trust[i][0] ≠ trust[i][1]

Visualization

Tap to expand

Understanding the Visualization

Map Relationships

Visualize trust as arrows: person A → person B means A trusts B

Count Connections

Judge has n-1 incoming arrows (trusted by all) and 0 outgoing arrows (trusts none)

Apply Score System

Use +1 for incoming trust, -1 for outgoing trust. Judge scores exactly n-1

Key Takeaway

🎯 Key Insight: The judge is like a celebrity in the trust network - everyone follows them, but they follow nobody back. Use the scoring system (+1 trusted, -1 trusts) to find them efficiently in one pass!

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 5

The optimal solution uses a clever trust score system in a single pass. Each person starts with score 0. When they trust someone, they lose a point (-1). When someone trusts them, they gain a point (+1). The town judge will have exactly n-1 points because they're trusted by everyone else but trust nobody themselves. This elegant approach runs in O(n) time and O(n) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Each Person)	O(n²)	O(1)	For each person, scan all trust relationships to count incoming and outgoing trusts
Two-Pass with Arrays	O(n + t)	O(n)	First pass: count trust relationships. Second pass: find person with correct counts
One-Pass Trust Score (Optimal)	O(n + t)	O(n)	Use a single array where being trusted adds points and trusting others subtracts points

Brute Force (Check Each Person) — Algorithm Steps

For each person from 1 to n
Count incoming trusts (how many trust this person)
Count outgoing trusts (how many this person trusts)
Check if incoming = n-1 and outgoing = 0
Return the person if conditions are met

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Person 1

Count how many trust person 1 and how many person 1 trusts

Check Person 2

Repeat the counting process for person 2

Find Judge

Continue until finding someone trusted by n-1 others who trusts nobody

Code -

solution.c — C

int findJudge(int n, int** trust, int trustSize, int* trustColSize) {
    // Check each person to see if they could be the judge
    for (int candidate = 1; candidate <= n; candidate++) {
        int trustedByCount = 0;  // How many people trust this candidate
        int trustsOthers = 0;    // How many people this candidate trusts
        
        // Count incoming trusts (people who trust this candidate)
        for (int i = 0; i < trustSize; i++) {
            if (trust[i][1] == candidate) {
                trustedByCount++;
            }
        }
        
        // Count outgoing trusts (people this candidate trusts)
        for (int i = 0; i < trustSize; i++) {
            if (trust[i][0] == candidate) {
                trustsOthers++;
            }
        }
        
        // Judge must be trusted by everyone else and trust nobody
        if (trustedByCount == n - 1 && trustsOthers == 0) {
            return candidate;
        }
    }
    
    return -1;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n people, we scan through all trust relationships

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables for counting, no extra data structures

✓ Linear Space

89.5K Views

High Frequency

~12 min Avg. Time

2.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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check Each Person) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler