# Solving Leetcode Interviews in Seconds with AI: Longest Subsequence Repeated k Times


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2014" 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 s of length n, and an integer k. You are tasked to find the longest subsequence repeated k times in string s. A subsequence is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters. A subsequence seq is repeated k times in the string s if seq * k is a subsequence of s, where seq * k represents a string constructed by concatenating seq k times.  For example, "bba" is repeated 2 times in the string "bababcba", because the string "bbabba", constructed by concatenating "bba" 2 times, is a subsequence of the string "bababcba".  Return the longest subsequence repeated k times in string s. If multiple such subsequences are found, return the lexicographically largest one. If there is no such subsequence, return an empty string.   Example 1:   Input: s = "letsleetcode", k = 2 Output: "let" Explanation: There are two longest subsequences repeated 2 times: "let" and "ete". "let" is the lexicographically largest one.  Example 2:  Input: s = "bb", k = 2 Output: "b" Explanation: The longest subsequence repeated 2 times is "b".  Example 3:  Input: s = "ab", k = 2 Output: "" Explanation: There is no subsequence repeated 2 times. Empty string is returned.    Constraints:  n == s.length 2 <= n, k <= 2000 2 <= n < k * 8 s consists of lowercase English letters.  

	# Explanation
	Here's a breakdown of the approach and the Python code:

*   **Greedy Construction:** Start with the lexicographically largest possible characters ('z', 'y', ..., 'a'). For each character, check if adding it to the current subsequence results in a subsequence that appears k times in the input string. If it does, append the character and continue.
*   **Subsequence Check:** Implement a function to efficiently check if a candidate string (subsequence repeated k times) is indeed a subsequence of the input string.
*   **Lexicographical Maximization:** The algorithm inherently prioritizes the lexicographically largest characters, ensuring that if multiple subsequences of the same length exist, the lexicographically largest one is chosen.

*   **Runtime Complexity:** O(26 * n * k), where n is the length of the input string `s` and k is the repetition factor. In worst case, we iterate through 26 characters and perform subsequence check which takes O(n*k) time.
*   **Storage Complexity:** O(n*k), due to the space used by the concatenated string `repeated_subsequence`.

	
	# Code
	```python
	def longest_subsequence_repeated_k(s: str, k: int) -> str:
    """
    Finds the longest subsequence repeated k times in string s.

    Args:
        s: The input string.
        k: The number of repetitions.

    Returns:
        The longest subsequence repeated k times.
    """

    n = len(s)
    longest_subsequence = ""

    for char_code in range(ord('z'), ord('a') - 1, -1):
        char = chr(char_code)
        new_subsequence = longest_subsequence + char
        repeated_subsequence = new_subsequence * k

        i = 0
        j = 0
        while i < n and j < len(repeated_subsequence):
            if s[i] == repeated_subsequence[j]:
                j += 1
            i += 1

        if j == len(repeated_subsequence):
            longest_subsequence = new_subsequence

    return longest_subsequence
	```