feat(algorithms, arrays): tournament winner

Tournament winner algorithm to determine wthe winner in a tournament

Author: BrianLusina

algorithms/arrays/sorted_squared_array/test_sorted_squared_array.py

@@ -17,6 +17,13 @@ def test_2(self):
         actual = sorted_squared_array(input_array)
         self.assertEqual(expected, actual)
 
+    def test_3(self):
+        """for an input of [-7,-3,2,3,11] it should return [4,9,9,49,121]"""
+        input_array = [-7,-3,2,3,11]
+        expected = [4,9,9,49,121]
+        actual = sorted_squared_array(input_array)
+        self.assertEqual(expected, actual)
+
 
 class SortedSquaredArray2TestCases(unittest.TestCase):
     def test_1(self):
@@ -33,6 +40,13 @@ def test_2(self):
         actual = sorted_squared_array_2(input_array)
         self.assertEqual(expected, actual)
 
+    def test_3(self):
+        """for an input of [-7,-3,2,3,11] it should return [4,9,9,49,121]"""
+        input_array = [-7,-3,2,3,11]
+        expected = [4,9,9,49,121]
+        actual = sorted_squared_array_2(input_array)
+        self.assertEqual(expected, actual)
+
 
 if __name__ == '__main__':
     unittest.main()

puzzles/arrays/tournament_winner/README.md

@@ -0,0 +1,63 @@
+# Tournament Winner
+
+There's an algorithms tournament taking place in which teams of programmers
+compete against each other to solve algorithmic problems as fast as possible.
+Teams compete in a round robin, where each team faces off against all other
+teams. Only two teams compete against each other at a time, and for each
+competition, one team is designated the home team, while the other team is the
+away team. In each competition there's always one winner and one loser; there
+are no ties. A team receives 3 points if it wins and 0 points if it loses. The
+winner of the tournament is the team that receives the most amount of points.
+
+Given an array of pairs representing the teams that have competed against each
+other and an array containing the results of each competition, write a
+function that returns the winner of the tournament. The input arrays are named
+`competitions` and `results`, respectively. The
+`competitions` array has elements in the form of
+`[homeTeam, awayTeam]`, where each team is a string of at most 30
+characters representing the name of the team. The `results` array
+contains information about the winner of each corresponding competition in the
+`competitions` array. Specifically, `results[i]` denotes
+the winner of `competitions[i]`, where a <span>1</span> in the
+`results` array means that the home team in the corresponding
+competition won and a `0` means that the away team won.
+
+It's guaranteed that exactly one team will win the tournament and that each
+team will compete against all other teams exactly once. It's also guaranteed
+that the tournament will always have at least two teams.
+
+```plain
+Sample Input
+
+competitions = [["HTML", "C#"], ["C#", "Python"], ["Python", "HTML"]]
+results = [0, 0, 1]
+
+Sample Output
+"Python"
+
+Explanation
+C# beats HTML, Python beats C#, and Python beats HTML.
+HTLM - 0 points
+C# - 3 points
+Python - 6 points
+That means that Python is the tournament winner and we return "Python".
+```
+
+## Hints
+
+1. Don't overcomplicate this problem. How would you solve it by hand? Consider that approach and try to translate it 
+   into code
+2. Use a hash table to store the total points collected by each team, with the team names as the keys in the hash table. 
+   Once you know how many points each team has, how can you determine which one is the winner?
+3. Loop through all of the competitions, and update the hash table at every
+  iteration. For each competition, consider the name of the winning team; if the
+  name already exists in the hash table, update that entry by adding 3 points to
+  it. If the team name doesn't exist in the hash table, add a new entry in the
+  hash table with the key as the team name and the value as 3 (since the team
+  won its first competition). While looping through all of the competitions,
+  keep track of the team with the highest score, and at the end of the
+  algorithm, return the team with the highest score.
+
+## Optimal Space & Time Complexity
+
+O(n) time | O(k) space - where n is the number of competitions and k is the number of teams

puzzles/arrays/tournament_winner/__init__.py

@@ -0,0 +1,28 @@
+from typing import List, Dict
+
+
+def tournament_winner(competitions: List[List[str]], results: List[int]) -> str:
+    # We need to store a dictionary with the name of the team as the key and the number of points as the value
+    # 3 points for a win, 0 points for a loss
+    winner = ""
+    teams: Dict[str, int] = {}
+    for competition, result in zip(competitions, results):
+        # result of 0 means that the away team won
+        # add the teams to the dictionary with the number of points
+        home_team = competition[0]
+        away_team = competition[1]
+
+        teams[home_team] = teams.get(home_team, 0)
+        teams[away_team] = teams.get(away_team, 0)
+
+        if result == 0:
+            teams[away_team] = teams.get(away_team, 0) + 3
+        else:
+            teams[home_team] = teams.get(home_team, 0) + 3
+
+    # find the team with the most points
+    for team, points in teams.items():
+        if points > teams.get(winner, 0):
+            winner = team
+
+    return winner

puzzles/arrays/tournament_winner/test_tournament_winner.py

@@ -0,0 +1,21 @@
+import unittest
+from . import tournament_winner
+
+class TournamentWinnerTestCase(unittest.TestCase):
+    def test_1(self):
+        competitions = [["HTML", "C#"], ["C#", "Python"], ["Python", "HTML"]]
+        results = [0, 0, 1]
+        expected = "Python"
+        actual = tournament_winner(competitions, results)
+        self.assertEqual(expected, actual)
+
+    def test_2(self):
+        competitions = [["HTML", "Java"],["Java", "Python"],["Python", "HTML"]]
+        results = [0, 1, 1]
+        expected = "Java"
+        actual = tournament_winner(competitions, results)
+        self.assertEqual(expected, actual)
+
+
+if __name__ == '__main__':
+    unittest.main()