feat(algorithms): new algorithm challenges

Author: BrianLusina

algorithms/counting/__init__.py

@@ -0,0 +1,106 @@
+# Rank Teams by Votes
+
+In a special ranking system, each voter gives a rank from highest to lowest to all teams participating in the competition.
+
+The ordering of teams is decided by who received the most position-one votes. If two or more teams tie in the first 
+position, we consider the second position to resolve the conflict, if they tie again, we continue this process until the
+ties are resolved. If two or more teams are still tied after considering all positions, we rank them alphabetically
+based on their team letter.
+
+You are given an array of strings votes which is the votes of all voters in the ranking systems. Sort all teams according
+to the ranking system described above.
+
+Return a string of all teams sorted by the ranking system.
+
+## Examples
+
+Example 1:
+```text
+Input: votes = ["ABC","ACB","ABC","ACB","ACB"]
+Output: "ACB"
+Explanation: 
+Team A was ranked first place by 5 voters. No other team was voted as first place, so team A is the first team.
+Team B was ranked second by 2 voters and ranked third by 3 voters.
+Team C was ranked second by 3 voters and ranked third by 2 voters.
+As most of the voters ranked C second, team C is the second team, and team B is the third.
+```
+
+Example 2:
+```text
+Input: votes = ["WXYZ","XYZW"]
+Output: "XWYZ"
+Explanation:
+X is the winner due to the tie-breaking rule. X has the same votes as W for the first position, but X has one vote in
+the second position, while W does not have any votes in the second position. 
+```
+
+Example 3:
+
+```text
+Input: votes = ["ZMNAGUEDSJYLBOPHRQICWFXTVK"]
+Output: "ZMNAGUEDSJYLBOPHRQICWFXTVK"
+Explanation: Only one voter, so their votes are used for the ranking.
+```
+
+## Constraints
+
+- 1 <= votes.length <= 1000
+- 1 <= votes[i].length <= 26
+- votes[i].length == votes[j].length for 0 <= i, j < votes.length.
+- votes[i][j] is an English uppercase letter.
+- All characters of votes[i] are unique.
+- All the characters that occur in votes[0] also occur in votes[j] where 1 <= j < votes.length.
+
+## Hints
+
+- Build array rank where rank[i][j] is the number of votes for team i to be the j-th rank.
+- Sort the teams by rank array. if rank array is the same for two or more teams, sort them by the ID in ascending order.
+
+## Topics
+
+- Array
+- Hash Table
+- String
+- Sorting
+- Counting
+
+## Solution
+
+The key intuition for solving this problem is to efficiently keep track of the vote counts each team receives for each
+position. We create a 2D array for this purpose, where the rows represent the teams and the columns represent the vote
+counts for each position. For each team in `votes[i][j]`, we update its vote count at the jth index in the counts array.
+After processing all votes, we sort the counts array based on the values in each row, prioritizing the row with the
+lowest value at the first index. If there is a tie, the row with the lowest value at the second index takes precedence,
+and so on. The final result is constructed using team's name corresponding to each row in the sorted array.
+
+Using the above intuition, the solution can be implemented as follows:
+
+1. Create a 2D array counts with dimensions 26×27 to store vote counts for each team.
+   - The first dimension (26) corresponds to the teams (A–Z), as there can be a maximum of 26 teams.
+   - The second dimension (27) holds the vote counts for each rank. Because there can be a maximum of 26 teams, the
+     maximum rank a team can get is 26 . It includes an additional column to store the team’s name to ensure that we
+     don’t lose track of which team’s data is in each row after sorting.
+2. For each team index t, store the team’s name at counts[t][26]. This keeps track of which team corresponds to each row
+   in the counts array.
+3. Start iterating through each string votes[i] to process the ranking given by each voter.
+4. For each character `votes[i][j]` representing a team in the vote, decrement its rank in the counts. This is because each
+   row in counts denotes the rank of a team; a lower count indicates a higher rank.
+5. Sort the counts array based on the values in each row. The sorting is done such that the row with the lowest value at
+   the first index comes first. If there is a tie, the row with the lowest value at the second index takes precedence,
+   and so on.
+6. Construct the final result by retrieving the team name stored at the last index (counts[i][26]) in the sorted counts.
+7. Return the constructed result, which contains all teams sorted according to the specified ranking system.
+
+### Time Complexity
+
+Given the length of the votes is n, the time complexity can be calculates as:
+
+- The time complexity of iterating each character in each string in votes is O(n×26), which is simplified to O(n).
+- The time complexity of sorting counts is `O(26×26log(26))`, which is simplified to O(1)
+- The time complexity of building the result string is O(26), which is simplified to O(1).
+
+Therefore, the time complexity of the above algorithm is O(n).
+
+### Space Complexity
+
+The algorithm’s space complexity is O(26×27) occupied by counts, which is simplified to O(1).

algorithms/counting/rank_teams_by_votes/README.md

@@ -0,0 +1,61 @@
+from typing import DefaultDict, List
+from collections import defaultdict
+
+
+def rank_teams_using_hash_map(votes: List[str]) -> str:
+    """
+    Ranks teams given a list of votes.
+    Args:
+        votes (List[str]): List of votes.
+    Returns:
+        str: Correctly ranked teams.
+    """
+    if not votes:
+        return ""
+    if len(votes) == 1:
+        return votes[0]
+
+    # each team's number of votes is equal
+    votes_per_team = len(votes[0])
+    # stores a mapping of the team's name to the number of votes per position
+    # so, e.g. {'A': [5, 0, 0], 'B': [0, 2, 3], ...}, indicates that A received 5 votes for position 1
+    # and B received 2 votes for position 2 and 3 for position 3, etc.
+    teams: DefaultDict[str, List[int]] = defaultdict(list)
+
+    # Iterate through the votes. Getting the position each voter ranked the given team
+    for voter in votes:
+        # For each voter, get where they ranked the given team
+        for position, team in enumerate(voter):
+            # If the team already exists in the mapping
+            if team in teams:
+                teams[team][position] += 1
+            else:
+                # the team has not yet been captured, so, we set the count of votes per team
+                teams[team] = [0] * votes_per_team
+                teams[team][position] = 1
+
+    sorted_teams = sorted(
+        teams.items(), key=lambda item: ([-x for x in item[1]], item[0])
+    )
+
+    return "".join(t[0] for t in sorted_teams)
+
+
+def rank_teams_counting(votes: List[str]) -> str:
+    counts: List[List[int | str]] = [[0] * 27 for _ in range(26)]
+
+    for t in range(26):
+        counts[t][26] = chr(ord("A") + t)
+
+    for i in range(len(votes)):
+        for j, c in enumerate(votes[i]):
+            counts[ord(c) - ord("A")][j] -= 1
+
+    counts.sort()
+
+    res = ""
+
+    for i in range(len(votes[0])):
+        res += counts[i][26]
+
+    return res

algorithms/counting/rank_teams_by_votes/__init__.py

@@ -0,0 +1,30 @@
+import unittest
+from typing import List
+from parameterized import parameterized
+
+from algorithms.counting.rank_teams_by_votes import (
+    rank_teams_using_hash_map,
+    rank_teams_counting,
+)
+
+RANK_TEAMS_BY_VOTES_TEST_CASES = [
+    (["ABC", "ACB", "ABC", "ACB", "ACB"], "ACB"),
+    (["WXYZ", "XYZW"], "XWYZ"),
+    (["ZMNAGUEDSJYLBOPHRQICWFXTVK"], "ZMNAGUEDSJYLBOPHRQICWFXTVK"),
+]
+
+
+class RankTeamsTestCase(unittest.TestCase):
+    @parameterized.expand(RANK_TEAMS_BY_VOTES_TEST_CASES)
+    def test_rank_teams_hash_map(self, votes: List[str], expected: str):
+        actual = rank_teams_using_hash_map(votes)
+        self.assertEqual(expected, actual)
+
+    @parameterized.expand(RANK_TEAMS_BY_VOTES_TEST_CASES)
+    def test_rank_teams_counting(self, votes: List[str], expected: str):
+        actual = rank_teams_counting(votes)
+        self.assertEqual(expected, actual)
+
+
+if __name__ == "__main__":
+    unittest.main()

algorithms/counting/rank_teams_by_votes/test_rank_teams_by_votes.py

@@ -12,7 +12,7 @@ def appeal_sum_dp(s: str) -> int:
 
     for idx, char in enumerate(s):
         # Convert character to index (0-25 for a-z)
-        char_index = ord(char) - ord('a')
+        char_index = ord(char) - ord("a")
         # Calculate new substrings that include current character
         # These are all substrings from (last occurrence of char + 1) to current_index
         # Each adds 1 to the appeal count if char wasn't in that substring before
@@ -26,6 +26,7 @@ def appeal_sum_dp(s: str) -> int:
 
     return total_appeal_sum
 
+
 def appeal_sum_hash_table(s: str) -> int:
     # Create a hash map to track the last occurrence index of each character
     track = defaultdict(lambda: -1)
@@ -47,4 +48,4 @@ def appeal_sum_hash_table(s: str) -> int:
         track[c] = i
 
     # Return the total appeal sum
-    return appeal
+    return appeal

algorithms/dynamic_programming/total_appeal_of_a_string/__init__.py

@@ -1,6 +1,9 @@
 import unittest
 from parameterized import parameterized
-from algorithms.dynamic_programming.total_appeal_of_a_string import appeal_sum_dp, appeal_sum_hash_table
+from algorithms.dynamic_programming.total_appeal_of_a_string import (
+    appeal_sum_dp,
+    appeal_sum_hash_table,
+)
 
 APPEAL_SUM_TEST_CASES = [
     ("abbca", 28),
@@ -12,6 +15,7 @@
     ("hippopotamus", 279),
 ]
 
+
 class AppealSumTestCase(unittest.TestCase):
     @parameterized.expand(APPEAL_SUM_TEST_CASES)
     def test_appeal_sum_dp(self, s: str, expected: int):
@@ -23,5 +27,6 @@ def test_appeal_sum_hash_table(self, s: str, expected: int):
         actual = appeal_sum_hash_table(s)
         self.assertEqual(expected, actual)
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     unittest.main()

algorithms/dynamic_programming/total_appeal_of_a_string/test_appeal_of_a_string.py

@@ -33,3 +33,58 @@ Input: grid = [
 ["0","0","0","1","1"]
 ]
 Output: 3
+
+---
+# Number of Distinct Islands
+
+Given an m x n binary matrix where 1 represents land and 0 represents water. An island is a group of connected 1s that
+are adjacent horizontally or vertically. Two islands are considered the same if one matches the other without rotating
+or flipping. The task is to return the number of distinct islands.
+
+## Constraints
+
+- m == grid.length
+- n == grid[i].length
+- 1≤ m, n ≤ 100
+- grid[i][j] is either 0 or 1.
+
+## Examples
+
+![Example 1](./images/examples/number_of_distinct_islands_example_1.png)
+![Example 2](./images/examples/number_of_distinct_islands_example_2.png)
+![Example 3](./images/examples/number_of_distinct_islands_example_3.png)
+![Example 4](./images/examples/number_of_distinct_islands_example_4.png)
+
+### Solution
+
+This algorithm is designed to find the number of distinct islands in a grid, where each island is a group of connected 
+1s. The idea is to treat the grid as a map and perform a depth-first search(DFS) to explore every piece of land. During
+DFS, the shape of the island is stored by the relative positions of land cells to the initial starting point of the
+island. This means the coordinates are normalized so that two islands can be compared even in different locations on the
+grid. These shapes are stored in the dictionary as keys, and the count of islands having the same shape is stored as a
+value. The result is the number of keys in the dictionary, which represents the distinct islands.
+Here’s the step-by-step implementation of the solution:
+- Initialize a set to track visited land cells and a dictionary to store the shapes of islands.
+- Loop through every cell in the grid. For each unvisited cell containing 1:
+  - Call DFS on the cell. 
+  - Explore all connected land cells recursively in all four directions (up, down, left, right) until the entire island
+    is mapped. 
+  - Normalize every land cell included in an island by subtracting the coordinates of that land cell from the coordinates
+    of the first cell in the respective island.
+  
+- Once DFS completes exploring an island, the shape is stored in the dictionary. The key in this dictionary represents
+  the shape, and the value is a count of the islands having the same shape.
+- After processing the entire grid, return the dictionary as the number of distinct island shapes is the number of unique
+  keys in the dictionary.
+
+### Time Complexity
+
+The time complexity of this solution is O(m*n), where n is the number of rows and m is the number of columns in the grid.
+This is because the DFS visits every cell exactly once, and each cell is processed in constant time as it checks the
+surrounding cells for potential land connections. The total time to explore all islands is proportional to the grid size.
+
+### Space Complexity
+
+The space complexity of this solution is O(m*n), where n is the number of rows and m is the number of columns. This is
+because the set and dictionary store up to m*n entries in the worst case, where every cell is a land cell. Additionally,
+the recursion depth of the DFS can reach m*n if the grid is entirely land.