feat(strings): lexicographically largest string in box

Author: BrianLusina

datastructures/linked_lists/singly_linked_list/single_linked_list.py

@@ -90,7 +90,6 @@ def insert_after_node(self, prev_node: Any, data: Any):
             current = current.next
 
     def insert_before_node(self, next_key: Any, data: T):
-
         pass
 
     def get_nth_node(self, position: int) -> Union[SingleNode, None]:

datastructures/lists/is_sorted_how/__init__.py

@@ -15,7 +15,9 @@ def is_sorted_and_how_2(arr):
     return (
         "yes, ascending"
         if is_sorted_with(arr, operator.le)
-        else "yes, descending" if is_sorted_with(arr, operator.ge) else "no"
+        else "yes, descending"
+        if is_sorted_with(arr, operator.ge)
+        else "no"
     )
 
 

machine_learning/soccer_predictions/features.py

@@ -78,9 +78,7 @@
     ON cur.matchid = opp.matchid
     WHERE cur.teamid != opp.teamid
     ORDER BY cur.matchid, cur.teamid
-      """ % {
-    "team_game_summary": match_stats.team_game_summary_query()
-}
+      """ % {"team_game_summary": match_stats.team_game_summary_query()}
 
 
 def get_match_history(history_size):
@@ -286,9 +284,7 @@ def get_wc_history_query(history_size):
     return """
         SELECT * FROM (%(history_query)s) WHERE competitionid = 4
         ORDER BY timestamp DESC, matchid, is_home
-        """ % {
-        "history_query": get_history_query(history_size)
-    }
+        """ % {"history_query": get_history_query(history_size)}
 
 
 def get_wc_features(history_size):

machine_learning/soccer_predictions/match_stats.py

@@ -65,9 +65,7 @@
 WHERE dist < 40)
 GROUP BY matchid, teamid
 ORDER BY matchid, teamid
-   """ % {
-    "touch_table": _TOUCH_TABLE
-}
+   """ % {"touch_table": _TOUCH_TABLE}
 
 # Subquery to compute raw number of goals scored. Does not take
 # into account own-goals (i.e. if a player scores an own-goal against

puzzles/arrays/lucky_numbers_in_a_matrix/test_lucky_numbers_in_a_matrix.py

@@ -8,7 +8,6 @@
 
 
 class LuckyNumbersInAMatrixTestCase(unittest.TestCase):
-
     @parameterized.expand(
         [
             ([[3, 7, 8], [9, 11, 13], [15, 16, 17]], [15]),

puzzles/graphs/number_of_islands/union_find.py

@@ -1,5 +1,4 @@
 class UnionFind:
-
     # Initializing the parent list and count variable by traversing the grid
     def __init__(self, grid):
         self.parent = []

puzzles/poker/__init__.py

@@ -48,7 +48,9 @@ def hand_rank(hand):
                                     else (
                                         2
                                         if counts == (2, 2, 1)
-                                        else 1 if counts == (2, 1, 1, 1) else 0
+                                        else 1
+                                        if counts == (2, 1, 1, 1)
+                                        else 0
                                     )
                                 )
                             )

pystrings/lexicographically_largest_string/README.md

@@ -0,0 +1,30 @@
+# Find the Lexicographically Largest String From Box
+
+You are given a string, word, and an integer numFriends, representing the number of friends participating in a game 
+organized by Alice.
+
+The game consists of multiple rounds, and in each round:
+- The string word is split into exactly numFriends non-empty substrings.
+- The split must be unique; no previous round has produced the same sequence of splits.
+- All resulting substrings from the split are placed into a box.
+
+When all rounds are over and all possible unique splits have been performed, determine the lexicographically largest 
+string among all the substrings in the box.
+
+> A string `a` is considered lexicographically larger than a string `b` if:
+> - At the first position where `a` and `b` differ, the character in `a` comes later than the corresponding character in 
+`b` in the alphabet.
+> - If `a` is a prefix of `b`, the longer string is considered larger.
+ 
+**Constraints**
+
+- 1 ≤ `word.length` ≤ 10^3
+- `word` consists only of lowercase English letters.
+- 1 ≤ `numFriends` ≤ `word.length`
+
+## Examples
+
+![Example 1](./images/examples/lexicographically_largest_string_from_box_example_1.png)
+![Example 2](./images/examples/lexicographically_largest_string_from_box_example_2.png)
+![Example 3](./images/examples/lexicographically_largest_string_from_box_example_3.png)
+![Example 4](./images/examples/lexicographically_largest_string_from_box_example_4.png)

pystrings/lexicographically_largest_string/__init__.py

@@ -0,0 +1,37 @@
+def lexicographically_largest_string_from_box(word: str, num: int) -> str:
+    n = len(word)
+    max_substring = ""
+
+    # Iterate through every possible starting character of a substring
+    for i in range(n):
+        # We want to find the longest valid substring starting at i.
+        # To do this, we assume this substring acts as the m-th part
+        # of the split, where m is as large as possible (latest slot).
+
+        # If we start at 0, we MUST be the 1st part.
+        if i == 0:
+            m = 1
+        else:
+            # If we start later, we can be at most the (i+1)-th part
+            # (since parts 1..m-1 need at least 1 char each).
+            # We are also capped by the total number of friends.
+            if num == 1:
+                # If only 1 num, the part MUST start at 0. i > 0 is invalid.
+                continue
+            m = min(num, i + 1)
+
+        # Calculate how many parts must come AFTER this one
+        parts_after = num - m
+
+        # The substring must end early enough to leave 1 char
+        # for each remaining part.
+        j = n - parts_after
+
+        # If the derived end index j is not greater than i,
+        # this split isn't possible (substring would be empty).
+        if j > i:
+            candidate = word[i:j]
+            if candidate > max_substring:
+                max_substring = candidate
+
+    return max_substring