रीकर्सन का उपयोग करके लेक्सिकोग्राफिक क्रम में स्ट्रिंग के सभी क्रमपरिवर्तन प्रिंट करने का पायथन प्रोग्राम

जब रीकर्सन का उपयोग करके लेक्सिकोग्राफिक क्रम में स्ट्रिंग के सभी क्रमपरिवर्तन प्रिंट करने हों, तो एक विधि परिभाषित की जाती है जो एलिमेंट्स के क्रम पर पुनरावृति करने के लिए 'for' लूप का उपयोग करती है और एलिमेंट्स को जोड़ने के लिए 'join' मेथड का उपयोग करती है।

उदाहरण

from math import factorial

def lexicographic_permutation_order(s):
    my_sequence = list(s)
    for _ in range(factorial(len(my_sequence))):
        print(''.join(my_sequence))
        next = next_in_permutation(my_sequence)
        if next is None:
            my_sequence.reverse()
        else:
            my_sequence = next

def next_in_permutation(my_sequence):
    if len(my_sequence) == 0:
        return None
    next = next_in_permutation(my_sequence[1:])
    if next is None:
        my_sequence[1:] = reversed(my_sequence[1:])
        q = 1
        while q < len(my_sequence) and my_sequence[0] > my_sequence[q]:
            q += 1
        if q == len(my_sequence):
            return None
        my_sequence[0], my_sequence[q] = my_sequence[q], my_sequence[0]
        return my_sequence
    else:
        return [my_sequence[0]] + next

my_input = input('एक स्ट्रिंग दर्ज करें: ')
print("स्ट्रिंग है:")
print(my_input)
print("विधि कॉल की जा रही है...")
lexicographic_permutation_order(my_input)

आउटपुट

एक स्ट्रिंग दर्ज करें: hey
स्ट्रिंग है: hey
विधि कॉल की जा रही है...
hey
hye
yeh
yhe
hey
hye

व्याख्या

• आवश्यक पैकेज आयात किए जाते हैं।

• 'lexicographic_permutation_order' नामक एक विधि परिभाषित की जाती है जो एलिमेंट्स के लेक्सिकोग्राफिक क्रम को खोजने में मदद करती है।

• 'next_in_permutation' मेथड स्ट्रिंग में अगले क्रमपरिवर्तन को निर्धारित करने में मदद करती है।

• उपयोगकर्ता द्वारा एक स्ट्रिंग दर्ज की जाती है और कंसोल पर प्रदर्शित की जाती है।

• इस स्ट्रिंग को पैरामीटर के रूप में पास करके विधि को कॉल किया जाता है।

• आउटपुट कंसोल पर प्रदर्शित होता है।