पायथन में 1 से n तक के लेक्सिकोग्राफिक क्रम से kth अनुक्रम ज्ञात करने का प्रोग्राम

मान लीजिए हमारे पास n और k दो मान हैं। अब 1 से n तक की संख्याओं की एक सूची [1, 2, ..., n] पर विचार करें और इस सूची के हर क्रमचय को लेक्सिकोग्राफिक क्रम में उत्पन्न करें। उदाहरण के लिए, यदि n = 4 तो हमारे पास [1234, 1243, 1324, 1342, 1423, 1432, 2134, 2143, 2314, 2341, 2413, 2431, 3124, 3142, 3214, 3241, 3412, 3421, 4123, 4132, 4213, 4231, 4312, 4321] होगा। हमें इस क्रमचय अनुक्रम के kth मान को स्ट्रिंग के रूप में ज्ञात करना है।

इसलिए, यदि इनपुट n = 4 k = 5 जैसा है, तो आउटपुट "1432" होगा।

हल करने के चरण

factors() फ़ंक्शन परिभाषित करें। यह num लेगा
- quo := num
- res := एक डबल एंडेड क्यू और शुरुआत में 0 डालें
- i := 2
- जब तक quo खाली नहीं है, करें
  - quo := (quo / i) का भागफल, rem := quo mod i
  - res के बाएं में rem डालें
  - i := i + 1
- res लौटाएं
मुख्य विधि से निम्नलिखित करें:
- numbers := 1 से n तक के मानों वाली सूची
- res := खाली स्ट्रिंग
- k_fact := factors(k)
- जब तक k_fact का आकार, numbers के आकार से कम है, करें
  - res := res + numbers के पहले तत्व को स्ट्रिंग में बदलकर, फिर numbers का पहला तत्व हटाएं
- k_fact में प्रत्येक index के लिए, करें
  - number := numbers का index-वां तत्व, फिर उस तत्व को हटाएं
  - res := res + number
- res लौटाएं

उदाहरण

from collections import deque

def factors(num):
    quo = num
    res = deque([0])
    i = 2
    while quo:
        quo, rem = divmod(quo, i)
        res.appendleft(rem)
        i += 1
    return res

class Solution:
    def solve(self, n, k):
        numbers = [num for num in range(1, n + 1)]
        res = ""
        k_fact = factors(k)
        while len(k_fact) < len(numbers):
            res += str(numbers.pop(0))
        for index in k_fact:
            number = numbers.pop(index)
            res += str(number)
        return res

ob = Solution()
n = 4
k = 5
print(ob.solve(n, k))

इनपुट

4, 5