CareerCup

def get_tournament_winner(games_played):
    return (set([player[0] for player in games_played]) -  # O(N)
    set([win for winns in games_played for win in winns[1]]) ) # + O(N)

def test():
    input1 = [(1, [3,5,8,9]), (2, [1, 4, 6]), (3, [4, 9]), (4, [8])]
    winner = get_tournament_winner(input1)
    if winner != {2}:
        print(f"Test failed {winner}")
    else: 
        print("Test ok")

if __name__ == "__main__":
    test()

P1>P2 and P2>P3 implies P1>P3
The first question is basically finding the max in an array. First compare between P1 and P2, store the bigger one and then match the result with P3. This process goes on till PN.

The second question is basically sorting the players. This is merge sort where the results of the pairwise matches determine which element is larger.

int x

what was the input other than N?

What was the inputs other than N?

// players: [0, n-1]
// w[0] wins w[1]
func Question1(n int, wins [][]int) int {
	// Two iteration, but strictly O(1) space
	var loser int
	for _, w := range wins {
		loser = w[1]
		// mark loser's index using negative value
		wins[loser][0] = math.MinInt32 + abs(wins[loser][0])
	}

	for i := 0; i < n; i++ {
		// winner never loses
		if wins[i][0] > 0 {
			return i
		}
	}
	return -1
}
func Question2(n int, wins [][]int) []int {
	// topological sort
	// O(n) time, O(n) space
	games := make(map[int][]int)
	ans, degrees := make([]int, n), make([]int, n)
	for _, w := range wins {
		games[w[1]] = append(games[w[1]], w[0])
		degrees[w[0]]++
	}
	// there should always be all-game losers, otherwise the deadlock occurs
	var queue []int
	for i, in := range degrees {
		if in == 0 {
			queue = append(queue, i)
		}
	}

	for len(queue) > 0 {
		size := len(queue)
		for i := 0; i < size; i++ {
			cur := queue[i]
			n--
			ans[n] = queue[i]
			for _, winner := range games[cur] {
				degrees[winner]--
				if degrees[winner] == 0 {
					queue = append(queue, winner)
				}
			}
		}
		queue = queue[size:]
	}
	return ans
}