# Solving Leetcode Interviews in Seconds with AI: Minimum Adjacent Swaps to Reach the Kth Smallest Number


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1850" 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 num, representing a large integer, and an integer k. We call some integer wonderful if it is a permutation of the digits in num and is greater in value than num. There can be many wonderful integers. However, we only care about the smallest-valued ones.  For example, when num = "5489355142":  	 The 1st smallest wonderful integer is "5489355214". The 2nd smallest wonderful integer is "5489355241". The 3rd smallest wonderful integer is "5489355412". The 4th smallest wonderful integer is "5489355421".    Return the minimum number of adjacent digit swaps that needs to be applied to num to reach the kth smallest wonderful integer. The tests are generated in such a way that kth smallest wonderful integer exists.   Example 1:  Input: num = "5489355142", k = 4 Output: 2 Explanation: The 4th smallest wonderful number is "5489355421". To get this number: - Swap index 7 with index 8: "5489355142" -> "5489355412" - Swap index 8 with index 9: "5489355412" -> "5489355421"  Example 2:  Input: num = "11112", k = 4 Output: 4 Explanation: The 4th smallest wonderful number is "21111". To get this number: - Swap index 3 with index 4: "11112" -> "11121" - Swap index 2 with index 3: "11121" -> "11211" - Swap index 1 with index 2: "11211" -> "12111" - Swap index 0 with index 1: "12111" -> "21111"  Example 3:  Input: num = "00123", k = 1 Output: 1 Explanation: The 1st smallest wonderful number is "00132". To get this number: - Swap index 3 with index 4: "00123" -> "00132"    Constraints:  2 <= num.length <= 1000 1 <= k <= 1000 num only consists of digits.  

	# Explanation
	*   **Find the kth Permutation:** Determine the kth smallest wonderful integer (permutation) of the input number `num`. This is achieved by generating permutations in lexicographical order until the kth permutation greater than `num` is found. A modified version of the next permutation algorithm handles duplicate digits.
*   **Calculate Swaps:** Calculate the minimum number of adjacent swaps required to transform the original number `num` into the kth smallest wonderful integer. This is accomplished by iterating through the target permutation and, for each digit, finding its corresponding position in the original number and performing adjacent swaps to bring it to its correct position, accumulating the swap count.

*   **Time Complexity:** O(N\*K + N^2), where N is the length of the number string and K is the given integer. Finding the kth permutation is O(N\*K). Calculating the swaps is O(N^2) in the worst case.
*   **Space Complexity:** O(N), where N is the length of the number string to store the string and temporary variables.

	
	# Code
	```python
	def get_kth_permutation(num, k):
    import math

    digits = sorted(list(num))
    n = len(digits)
    result = ""
    k -= 1  # Adjust k to be 0-indexed

    while digits:
        fact = math.factorial(n - 1)
        index = k // fact
        result += digits[index]
        del digits[index]
        k %= fact
        n -= 1

    return result


def min_swaps(num, target):
    num_list = list(num)
    target_list = list(target)
    swaps = 0
    n = len(num_list)

    for i in range(n):
        if num_list[i] != target_list[i]:
            j = i + 1
            while num_list[j] != target_list[i]:
                j += 1

            while j > i:
                num_list[j], num_list[j - 1] = num_list[j - 1], num_list[j]
                swaps += 1
                j -= 1

    return swaps


def get_min_swaps(num, k):
    import itertools
    target_permutation = get_kth_permutation(num, k)

    return min_swaps(num, target_permutation)
	```