Is Team Dominance by Pass Success easy or hard?

It is rated Hard on FleetCode, but the core logic is a join followed by a GROUP BY with SUM. The difficulty usually comes from the ranking requirement and handling edge cases like ties. Get the join and aggregation right first, then add the ranking step.

How to solve Team Dominance by Pass Success in O(n)?

Join the team table to the match table on team_id so each match row carries its team name. Then GROUP BY the team and compute SUM of successful passes. Each match row is processed once during the join and once during aggregation, so the total work is linear in the input size.

Team Dominance by Pass Success Python or Java solution?

In Python, use pandas: merge the team and match DataFrames on team_id, then call groupby on the team name and sum the pass column. In Java or any other language, the same logic applies with a hash map keyed by team_id that accumulates pass totals. The SQL version with an equi-join and GROUP BY is the most direct answer for this problem.

What is the best approach for Team Dominance by Pass Success?

The best approach is an equi-join between the team and match tables, followed by GROUP BY on the team and SUM over successful passes. This aggregates each team in a single pass over the data. If the output needs ranks, add DENSE_RANK() over the aggregated totals.

What data structure is used in Team Dominance by Pass Success?

The solution relies on a hash-based join, where the database or Pandas builds a hash table keyed by team_id. The aggregation then accumulates sums in a hash map keyed by team. Ranking with DENSE_RANK() uses a sort over the aggregated results.

What is the time complexity of Team Dominance by Pass Success?

The optimal solution runs in O(T + M) time, where T is the number of teams and M is the number of match records. The join builds and probes a hash structure, and the GROUP BY aggregates in one linear pass. Adding a ranking step sorts the T aggregated rows, which raises the cost to O(T log T) for that step.

Is Team Dominance by Pass Success asked at Google, Amazon, or Meta?

This problem is tagged as a General database problem on FleetCode and is not labeled with company-specific tags here. Expect SQL join and GROUP BY questions like this in data-focused roles at large tech companies. Practice joins, aggregations, and window functions to cover the same skills.

Description Solution

3384. Team Dominance by Pass Success

Hard72.1% acceptancePremium elsewhere, free here

Table: Teams

+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| player_id   | int     |
| team_name   | varchar | 
+-------------+---------+
player_id is the unique key for this table.
Each row contains the unique identifier for player and the name of one of the teams participating in that match.

Table: Passes

+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| pass_from   | int     |
| time_stamp  | varchar |
| pass_to     | int     |
+-------------+---------+
(pass_from, time_stamp) is the primary key for this table.
pass_from is a foreign key to player_id from Teams table.
Each row represents a pass made during a match, time_stamp represents the time in minutes (00:00-90:00) when the pass was made,
pass_to is the player_id of the player receiving the pass.

Write a solution to calculate the dominance score for each team in both halves of the match. The rules are as follows:

A match is divided into two halves: first half (00:00-45:00 minutes) and second half (45:01-90:00 minutes)
The dominance score is calculated based on successful and intercepted passes:
- When pass_to is a player from the same team: +1 point
- When pass_to is a player from the opposing team (interception): -1 point
A higher dominance score indicates better passing performance

Return the result table ordered by team_name and half_number in ascending order.

The result format is in the following example.

Example:

Input:

Teams table:

+------------+-----------+
| player_id  | team_name |
+------------+-----------+
| 1          | Arsenal   |
| 2          | Arsenal   |
| 3          | Arsenal   |
| 4          | Chelsea   |
| 5          | Chelsea   |
| 6          | Chelsea   |
+------------+-----------+

Passes table:

+-----------+------------+---------+
| pass_from | time_stamp | pass_to |
+-----------+------------+---------+
| 1         | 00:15      | 2       |
| 2         | 00:45      | 3       |
| 3         | 01:15      | 1       |
| 4         | 00:30      | 1       |
| 2         | 46:00      | 3       |
| 3         | 46:15      | 4       |
| 1         | 46:45      | 2       |
| 5         | 46:30      | 6       |
+-----------+------------+---------+

Output:

+-----------+-------------+-----------+
| team_name | half_number | dominance |
+-----------+-------------+-----------+
| Arsenal   | 1           | 3         |
| Arsenal   | 2           | 1         |
| Chelsea   | 1           | -1        |
| Chelsea   | 2           | 1         |
+-----------+-------------+-----------+

Explanation:

First Half (00:00-45:00):
- Arsenal's passes:
  - 1 → 2 (00:15): Successful pass (+1)
  - 2 → 3 (00:45): Successful pass (+1)
  - 3 → 1 (01:15): Successful pass (+1)
- Chelsea's passes:
  - 4 → 1 (00:30): Intercepted by Arsenal (-1)
Second Half (45:01-90:00):
- Arsenal's passes:
  - 2 → 3 (46:00): Successful pass (+1)
  - 3 → 4 (46:15): Intercepted by Chelsea (-1)
  - 1 → 2 (46:45): Successful pass (+1)
- Chelsea's passes:
  - 5 → 6 (46:30): Successful pass (+1)
The results are ordered by team_name and then half_number

Still stuck?Read the written solution.

Open solution

LanguageLoading editor…

1class Solution:
  def solve(self):
      pass


Starter codePython 3Spaces: 4

Examples

No sample inputs for this problem yet. The examples in the statement show the format.

Your code is saved on this device.Solution