# Solving Leetcode Interviews in Seconds with AI: Find the Lexicographically Largest String From the Box I


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3403" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> You are given a string word, and an integer numFriends. Alice is organizing a game for her numFriends friends. There are multiple rounds in the game, where in each round:  word is split into numFriends non-empty strings, such that no previous round has had the exact same split. All the split words are put into a box.  Find the lexicographically largest string from the box after all the rounds are finished.   Example 1:  Input: word = "dbca", numFriends = 2 Output: "dbc" Explanation:  All possible splits are:  "d" and "bca". "db" and "ca". "dbc" and "a".   Example 2:  Input: word = "gggg", numFriends = 4 Output: "g" Explanation:  The only possible split is: "g", "g", "g", and "g".    Constraints:  1 <= word.length <= 5 * 103 word consists only of lowercase English letters. 1 <= numFriends <= word.length  

	# Explanation
	Here's the breakdown of the solution:

*   **Identify Possible Splits:** Generate all possible ways to split the given word into `numFriends` non-empty substrings.
*   **Lexicographical Comparison:** Keep track of the lexicographically largest substring encountered so far across all splits.
*   **Efficient Generation:** Optimize split generation to avoid unnecessary computations by iterating through substring lengths and indices appropriately.

*   **Runtime Complexity:** O(n<sup>2</sup>), where n is the length of the word.
*   **Storage Complexity:** O(n), where n is the length of the word, mainly for storing substrings and the maximum string.

	
	# Code
	```python
	def largest_split_string(word: str, numFriends: int) -> str:
    """
    Finds the lexicographically largest string from all possible splits of the word into numFriends parts.

    Args:
        word: The input string.
        numFriends: The number of friends (number of splits).

    Returns:
        The lexicographically largest string among all splits.
    """

    n = len(word)
    max_string = ""

    def generate_splits(index: int, current_split: list[str], remaining_friends: int):
        nonlocal max_string

        if remaining_friends == 1:
            current_split.append(word[index:])
            for s in current_split:
                if s > max_string:
                    max_string = s
            current_split.pop()
            return

        for i in range(index + 1, n - remaining_friends + 2):
            current_split.append(word[index:i])
            generate_splits(i, current_split, remaining_friends - 1)
            current_split.pop()

    generate_splits(0, [], numFriends)
    return max_string
	```