The person everyone trusts

def find_judge(n, trust):
    score = [0] * (n + 1)          # in-degree minus out-degree, labels 1..n
    for a, b in trust:
        score[a] -= 1              # a trusts someone: cannot be the judge
        score[b] += 1
    for person in range(1, n + 1):
        if score[person] == n - 1:
            return person
    return -1

#include <vector>

int solve(int n, const std::vector<std::vector<int>>& trust) {
    std::vector<int> score(n + 1, 0);       // in-degree minus out-degree
    for (const auto& t : trust) {
        --score[t[0]];
        ++score[t[1]];
    }
    for (int p = 1; p <= n; ++p)
        if (score[p] == n - 1) return p;
    return -1;
}

class Solution {
    public int findJudge(int n, int[][] trust) {
        int[] score = new int[n + 1];        // in-degree minus out-degree
        for (int[] t : trust) {
            score[t[0]]--;
            score[t[1]]++;
        }
        for (int p = 1; p <= n; p++) if (score[p] == n - 1) return p;
        return -1;
    }
}

function findJudge(n, trust) {
  const score = new Array(n + 1).fill(0);   // in-degree minus out-degree
  for (const [a, b] of trust) {
    score[a]--;
    score[b]++;
  }
  for (let p = 1; p <= n; p++) if (score[p] === n - 1) return p;
  return -1;
}

fn solve(n: i64, trust: &[[i64; 2]]) -> i64 {
    let mut score = vec![0i64; n as usize + 1];   // in-degree minus out-degree
    for t in trust {
        score[t[0] as usize] -= 1;
        score[t[1] as usize] += 1;
    }
    (1..=n).find(|&p| score[p as usize] == n - 1).unwrap_or(-1)
}

import qualified Data.Map.Strict as M

solve :: Int -> [[Int]] -> Int
solve n trust =
  case [p | p <- [1 .. n], M.findWithDefault 0 p score == n - 1] of
    (p : _) -> p
    [] -> -1
  where
    -- in-degree minus out-degree
    score = M.fromListWith (+) (concat [[(a, -1), (b, 1)] | [a, b] <- trust])