Constructive soln
Code
# Code
```python3 []
class Solution:
    def permute(self, n: int, k: int) -> List[int]:
        # Cache factorials for later use
        fact = {0 : 1}
        for i in range(1, n+1):
            fact[i] = fact[i-1] * i
        
        # Figure out how many entries to skip for each entry
        toSkip = []
        isEven = n % 2 == 0
        N = n
        while k != 1:
            amountSkippedPerEntry = fact[N//2 - (1 if isEven else 0)] * fact[N//2]
            numToSkip = ceil(k / amountSkippedPerEntry) - 1
            toSkip.append(numToSkip)
            isEven = not isEven
            k -= numToSkip * amountSkippedPerEntry
            N -= 1
        
        # If we don't have to skip anything, just return the list in order
        if not toSkip:
            return list(range(1, n+1))
        
        # Populate the rest of toSkip with 0's to represent no skips
        for _ in range(n - len(toSkip)):
            toSkip.append(0)

        # The numbers we skip for the starting value differs on whether n is even or not
        # If n is even, we can start with any number
        # If n is odd, we can only start with odd numbers
        # The first toSkip value represents different numbers based on this
        isEven = n % 2 == 0
        if isEven:
            firstVal = toSkip[0] + 1
        else:
            firstVal = 2 * toSkip[0] + 1
        
        if firstVal > n:
            return []

        # Constructing the rest of the solution
        availableNums = set(range(1, n+1))
        availableNums.remove(firstVal)
        ans = [firstVal]
        isEven = firstVal % 2 == 1
        
        for skip in toSkip[1:]:
            start = 2 if isEven else 1
            isEven = not isEven
            
            found = False
            for i in range(start, n+1, 2):
                if i in availableNums:
                    if skip == 0:
                        ans.append(i)
                        availableNums.remove(i)
                        found = True
                        break
                    skip -= 1

            if not found:
                return []

        return ans
```
['Python3']