अजगर में किसी दिए गए स्ट्रिंग के सभी संभावित क्रमांकन ढूंढना


93

मेरे पास एक तार है। मैं इसमें पात्रों के क्रम को बदलकर, उस स्ट्रिंग से सभी क्रमपरिवर्तन उत्पन्न करना चाहता हूं। उदाहरण के लिए, कहें:

x='stack'

मुझे जो चाहिए वह इस तरह की एक सूची है,

l=['stack','satck','sackt'.......]

वर्तमान में मैं स्ट्रिंग के लिस्ट कास्ट पर पुनरावृत्ति कर रहा हूं, 2 अक्षर बेतरतीब ढंग से उठा रहा हूं और उन्हें एक नया स्ट्रिंग बनाने के लिए ट्रांसपोज़ कर रहा हूं, और इसे एल की कास्ट सेट करने के लिए जोड़ रहा हूं। स्ट्रिंग की लंबाई के आधार पर, मैं संभव अनुमतियों की संख्या की गणना कर रहा हूं और सेट आकार तक सीमा तक निरंतर पुनरावृत्तियों को जारी रखता हूं। ऐसा करने का एक बेहतर तरीका होना चाहिए।

जवाबों:


148

Itertools मॉड्यूल में एक उपयोगी विधि है, जिसे क्रमपरिवर्तन () कहा जाता है। प्रलेखन कहता है:

itertools.permutations (पुनरावृत्त [, r])

पुनरावृत्ति की पुनरावृत्ति तत्वों में तत्वों की लंबाई क्रमपरिवर्तन।

यदि आर निर्दिष्ट नहीं है या कोई भी नहीं है, तो पुनरावृत्त की लंबाई तक चलने योग्य और सभी संभव पूर्ण-लंबाई क्रमपरिवर्तन उत्पन्न होते हैं।

क्रमबद्धता को शाब्दिक क्रम में उत्सर्जित किया जाता है। इसलिए, यदि इनपुट पुनरावृत्त क्रमबद्ध है, तो क्रमबद्ध क्रम में टुपल्स का उत्पादन किया जाएगा।

आपको अपने अनुमत पत्रों को तार के रूप में जोड़ना होगा।

>>> from itertools import permutations
>>> perms = [''.join(p) for p in permutations('stack')]
>>> perms

[[स्टैक ’, c स्टैक’, 'स्टैक ’, a स्टाका’, k स्टैक ’,, स्टक्क’, ck सैटक ’, k सैटक’, k सैक्टक ’, t सैक्ट’, ak सक्टक ’, ak सैक्ट’, ’ sctak ',' sctka ',' scatk ',' scakt ',' sckta ',' sckat ',' sktac ',' sktca ',' skatc ',' skacta ',' skcta ',' skcat ',' tsack ' , 'tsakc', 'tscak', 'tskac', 'tskac', 'tasck', 'taskc', 'tacsk', 'tacks', 'taksc', 'takcs', 'tcsak', ' tcska ',' tcask ',' tcaks ',' tckas ',' tksac ',' tksca ',' tkasc ',' tkacs ',' tkcsa ',' tkcas ',' astck ','astkc ',' asctk ',' asckt ',' asktc ',' askct ',' atsck ',' atskc ',' atcsk ',' atcks ',' atksc ',' atkcs ',' acstk ',' acskt ' , 'actsk', 'actks', 'ackst', 'ackts', 'akstc', 'aksct', 'aktsc', 'aktcs', 'akcst', 'akcts', 'cstak', 'cstka', ' सीसैटक, 'सिसकट', 'सस्कट', 'सस्कैट', 'सत्सक', 'सत्स्का', 'सत्सक', 'सत्तक', 'सप्तक', 'सप्तक', 'काटक', 'कास्क', 'कैटस्क', 'कैटस्क'। , 'कैटक्स', 'कैकस्ट', 'कैक्ट्स', 'क्कस्टा', 'क्कट्स', 'क्क्ट्सा', 'क्कटस', 'क्कस्ट', 'कॉकट्स', 'क्रिएट', 'क्स्टा', 'क्सटक्ट','ksact ’, ct kscta’, at kscat ’,' ktsac’, 'ktsca ’,' ktasc’, ac ktacs ’, t ktcsa’, c ktcas ’, ast kastc’, as kasct ’, ats katsc’, at katcs ’, ',' kacst ',' kacts ',' kcsta ',' kcsat ',' kctsa ',' kctas ',' kcast ',' kcats ']

यदि आप खुद को डुप्लिकेट से परेशान पाते हैं, तो अपने डेटा को किसी डुप्लिकेट की तरह संरचना में फिट करने का प्रयास करें set:

>>> perms = [''.join(p) for p in permutations('stacks')]
>>> len(perms)
720
>>> len(set(perms))
360

यह इंगित करने के लिए @pst के लिए धन्यवाद कि यह वह नहीं है जिसे हम परंपरागत रूप से एक प्रकार का कास्ट के रूप में सोचते हैं, बल्कि set()निर्माणकर्ता को कॉल के अधिक ।


3
नित: set(...)"कास्ट" नहीं करता है। इसके बजाय, यह इनपुट संग्रह का प्रतिनिधित्व करने वाले सेट (और पैदावार) को उत्पन्न करता है: एक बार उत्पन्न होने के बाद इसका इनपुट संग्रह के साथ कोई संबंध नहीं है (और यह एक अलग वस्तु है, न कि एक अलग दृश्य है)।

@pst: हम्म मैं असहमत होना चाहूंगा। मैं एडा या पास्कल में जानता हूं कि एक कलाकार एक ही बिट्स पर एक नया प्रकार है। हालाँकि, सी परिप्रेक्ष्य से कम से कम, कास्टिंग एक उपयुक्त शब्द है कि आप डेटा की अंतर्निहित संरचना को बदल रहे हैं या नहीं। यह केवल स्पष्ट प्रकार के रूपांतरण को संदर्भित करता है। यदि आप कर सकते हैं तो कृपया मेरी गलतफहमी दूर करें।
मशीन

1
टाइपकास्टिंग । हालांकि, जैसा कि आप बताते हैं, यह केवल एक दृश्य से अलग हो सकता है, मुझे भ्रम से बचने के लिए अवधारणाओं को अलग करने की कोशिश करना और रखना पसंद है। मुझे अपनी पहली टिप्पणी में स्पष्ट रूप से "जबरदस्ती" का उल्लेख करना चाहिए था, हालांकि मैं सिर्फ एक फ़ंक्शन: सूची -> सेट पर विचार करूंगा।

1
मैं इसे देखता हूं bool, यह एक फ़ंक्शन है जो इनपुट के आधार पर एक बूल (ट्रू / फाल्स) का मूल्यांकन करता है। मुझे लगता है कि यहाँ "कास्ट" का उपयोग बहुत ही भ्रामक और भ्रामक है ...

1
एक दिलचस्प अपडेट के रूप में, प्रलेखन को यह कहने के लिए बदल दिया गया है कि बिल्ट-इन फ़ंक्शन बूल () का उपयोग किसी भी मूल्य को बूलियन में परिवर्तित करने के लिए किया जा सकता है , विशेष रूप से कास्ट के बजाय परिवर्तित। इस चर्चा के बाद रिलीज में यह हुआ, जिससे मुझे विश्वास हो गया कि इस चर्चा से डॉक्स में बदलाव आएगा!
मशीन तड़के

47

आप सभी एन प्राप्त कर सकते हैं! अधिक कोड के बिना क्रमपरिवर्तन

def permutations(string, step = 0):

    # if we've gotten to the end, print the permutation
    if step == len(string):
        print "".join(string)

    # everything to the right of step has not been swapped yet
    for i in range(step, len(string)):

        # copy the string (store as array)
        string_copy = [character for character in string]

        # swap the current index with the step
        string_copy[step], string_copy[i] = string_copy[i], string_copy[step]

        # recurse on the portion of the string that has not been swapped yet (now it's index will begin with step + 1)
        permutations(string_copy, step + 1)

अच्छा है। पूरी तरह से काम करता है
kishorer747

1
मैंने इसे थोड़ा संशोधित किया है, हमें चर की अदला-बदली करने की आवश्यकता नहीं है यदि i == चरण
work_in_progress

4
रनटाइम O (n!) है क्योंकि n हैं! क्रमपरिवर्तन।
एस्पेन

आप step == len(string)इसके बजाय क्यों उपयोग कर रहे हैं step == len(string) - 1?
ट्यूलियां

क्योंकि तब अंतिम 2 आइटम कभी स्वैप नहीं किए जाते थे। 'Abc' को तब तक आज़माएँ जब तक b और c की अदला-बदली न हो जाए।
रोमन रेसेन

17

यहां न्यूनतम कोड के साथ स्ट्रिंग के क्रमचय करने का एक और तरीका है। हम मूल रूप से एक लूप बनाते हैं और फिर हम एक समय में दो वर्णों की अदला-बदली करते रहते हैं, लूप के अंदर हमारी पुनरावृत्ति होगी। ध्यान दें, हम केवल तब प्रिंट करते हैं जब इंडेक्सर्स हमारी स्ट्रिंग की लंबाई तक पहुंचते हैं। उदाहरण: एबीसी i हमारे शुरुआती बिंदु के लिए और हमारे लूप के लिए हमारी पुनरावृत्ति परम जे

यहां एक दृश्य सहायता है कि यह बाएं से दाएं ऊपर से नीचे तक कैसे काम करती है (क्रमपरिवर्तन का क्रम है)

यहाँ छवि विवरण दर्ज करें

कोड :

def permute(data, i, length): 
    if i==length: 
        print(''.join(data) )
    else: 
        for j in range(i,length): 
            #swap
            data[i], data[j] = data[j], data[i] 
            permute(data, i+1, length) 
            data[i], data[j] = data[j], data[i]  


string = "ABC"
n = len(string) 
data = list(string) 
permute(data, 0, n)

5
यह उल्लेख करना उपयोगी हो सकता है कि यह बैक्टैकिंग प्रतिमान का आधार है ।
अरुनिआरसी

अधिक जानकारी, समान / समान कोड: geeksforgeeks.org/… मैं आपके उदाहरण को ग्राफिक उदाहरणों के साथ बेहतर पसंद करता हूं।)
CTS_AE

8

स्टैक ओवरफ्लो उपयोगकर्ताओं ने पहले से ही कुछ मजबूत समाधान पोस्ट किए हैं, लेकिन मैं अभी तक एक और समाधान दिखाना चाहता था। यह मुझे अधिक सहज लगता है

विचार यह है कि किसी दिए गए स्ट्रिंग के लिए: हम एल्गोरिथ्म (छद्म-कोड) द्वारा पुनरावृत्ति कर सकते हैं:

permutations = char + क्रमपरिवर्तन (स्ट्रिंग - चार) स्ट्रिंग में चार के लिए

मुझे आशा है कि यह किसी की मदद करता है!

def permutations(string):
    """
    Create all permutations of a string with non-repeating characters
    """
    permutation_list = []
    if len(string) == 1:
        return [string]
    else:
        for char in string:
            [permutation_list.append(char + a) for a in permutations(string.replace(char, "", 1))]
    return permutation_list

4
यह उन मामलों के लिए काम नहीं करेगा जहां दोहराए जाने वाले वर्ण हैं (str.replace)। जैसे: rqqx
sanjay

उपयोग करें: क्रमपरिवर्तन (string.replace (char, "", 1)) के लिए [permutation_list.append (char + a)]
user3761855

7

यहाँ अद्वितीय क्रमपरिवर्तन वापस करने के लिए एक सरल कार्य है:

def permutations(string):
    if len(string) == 1:
        return string

    recursive_perms = []
    for c in string:
        for perm in permutations(string.replace(c,'',1)):
            revursive_perms.append(c+perm)

    return set(revursive_perms)

6
1. आपके पास एक टाइपो है: revursive_perms-> recursive_perms। 2. यह रैम और समय की बचत करेगा यदि recursive_permsएक सूची के बजाय एक सेट था जिसे आप रिटर्न स्टेटमेंट में सेट में परिवर्तित करते हैं। 3. .replaceआरजीएस के पुनरावर्ती कॉल के लिए आरजी के निर्माण के बजाय स्ट्रिंग स्लाइसिंग का उपयोग करना अधिक कुशल होगा permutations। 4. stringएक चर नाम के रूप में उपयोग करना एक अच्छा विचार नहीं है क्योंकि यह मानक stringमॉड्यूल के नाम को छाया देता है ।
PM 2Ring

5

यहाँ एक और दृष्टिकोण है जो @Adriano और @illerucis द्वारा पोस्ट किया गया है। यह एक बेहतर रनटाइम है, आप समय की माप करके खुद देख सकते हैं:

def removeCharFromStr(str, index):
    endIndex = index if index == len(str) else index + 1
    return str[:index] + str[endIndex:]

# 'ab' -> a + 'b', b + 'a'
# 'abc' ->  a + bc, b + ac, c + ab
#           a + cb, b + ca, c + ba
def perm(str):
    if len(str) <= 1:
        return {str}
    permSet = set()
    for i, c in enumerate(str):
        newStr = removeCharFromStr(str, i)
        retSet = perm(newStr)
        for elem in retSet:
            permSet.add(c + elem)
    return permSet

एक मनमाना स्ट्रिंग "डैडफैडएक्सकॉन्फ़" के लिए, यह क्रमांकन पुस्तकालय के लिए 1.1336 सेकंड, इस कार्यान्वयन के लिए 9.125 सेकंड और @ एड्रियनो और @illerucis 'संस्करण के लिए 16.357 सेकेंड का समय लिया। बेशक आप अभी भी इसे अनुकूलित कर सकते हैं।


4

itertools.permutationsअच्छा है, लेकिन यह बार-बार तत्वों को शामिल करने वाले दृश्यों से अच्छी तरह से नहीं निपटता है। ऐसा इसलिए है क्योंकि आंतरिक रूप से यह अनुक्रम सूचकांकों को अनुमति देता है और अनुक्रम आइटम मूल्यों से अनजान है।

ज़रूर, itertools.permutationsडुप्लिकेट को खत्म करने के लिए एक सेट के माध्यम से आउटपुट को फ़िल्टर करना संभव है , लेकिन यह अभी भी उन डुप्लिकेट को उत्पन्न करने में समय बर्बाद करता है, और यदि आधार अनुक्रम में कई दोहराया तत्व हैं तो बहुत सारे डुप्लिकेट होंगे। इसके अलावा, परिणाम कचरे को पकड़ने के लिए संग्रह का उपयोग करके, पहली जगह में एक पुनरावृत्ति का उपयोग करने के लाभ को नकारना।

सौभाग्य से, अधिक कुशल दृष्टिकोण हैं। नीचे दिया गया कोड 14 वीं शताब्दी के भारतीय गणितज्ञ नारायण पंडिता के एल्गोरिथ्म का उपयोग करता है, जिसे क्रमपरिवर्तन पर विकिपीडिया लेख में पाया जा सकता है । यह प्राचीन एल्गोरिथ्म अभी भी क्रम में क्रमपरिवर्तन उत्पन्न करने के लिए सबसे तेज़ ज्ञात तरीकों में से एक है, और यह काफी मजबूत है, इसमें यह उन क्रमपरिवर्तन को ठीक से संभालता है जिनमें बार-बार तत्व होते हैं।

def lexico_permute_string(s):
    ''' Generate all permutations in lexicographic order of string `s`

        This algorithm, due to Narayana Pandita, is from
        https://en.wikipedia.org/wiki/Permutation#Generation_in_lexicographic_order

        To produce the next permutation in lexicographic order of sequence `a`

        1. Find the largest index j such that a[j] < a[j + 1]. If no such index exists, 
        the permutation is the last permutation.
        2. Find the largest index k greater than j such that a[j] < a[k].
        3. Swap the value of a[j] with that of a[k].
        4. Reverse the sequence from a[j + 1] up to and including the final element a[n].
    '''

    a = sorted(s)
    n = len(a) - 1
    while True:
        yield ''.join(a)

        #1. Find the largest index j such that a[j] < a[j + 1]
        for j in range(n-1, -1, -1):
            if a[j] < a[j + 1]:
                break
        else:
            return

        #2. Find the largest index k greater than j such that a[j] < a[k]
        v = a[j]
        for k in range(n, j, -1):
            if v < a[k]:
                break

        #3. Swap the value of a[j] with that of a[k].
        a[j], a[k] = a[k], a[j]

        #4. Reverse the tail of the sequence
        a[j+1:] = a[j+1:][::-1]

for s in lexico_permute_string('data'):
    print(s)

उत्पादन

aadt
aatd
adat
adta
atad
atda
daat
data
dtaa
taad
tada
tdaa

बेशक, यदि आप एक सूची में उपज स्ट्रिंग्स को इकट्ठा करना चाहते हैं जो आप कर सकते हैं

list(lexico_permute_string('data'))

या हाल के पायथन संस्करणों में:

[*lexico_permute_string('data')]

खूबसूरती से समझाया।
लामो

2

आप सरल क्यों नहीं करते:

from itertools import permutations
perms = [''.join(p) for p in permutations(['s','t','a','c','k'])]
print perms
print len(perms)
print len(set(perms))

जैसा कि आप देख सकते हैं आपको कोई डुप्लिकेट नहीं मिला

 ['stack', 'stakc', 'stcak', 'stcka', 'stkac', 'stkca', 'satck', 'satkc', 
'sactk', 'sackt', 'saktc', 'sakct', 'sctak', 'sctka', 'scatk', 'scakt', 'sckta',
 'sckat', 'sktac', 'sktca', 'skatc', 'skact', 'skcta', 'skcat', 'tsack', 
'tsakc', 'tscak', 'tscka', 'tskac', 'tskca', 'tasck', 'taskc', 'tacsk', 'tacks', 
'taksc', 'takcs', 'tcsak', 'tcska', 'tcask', 'tcaks', 'tcksa', 'tckas', 'tksac', 
'tksca', 'tkasc', 'tkacs', 'tkcsa', 'tkcas', 'astck', 'astkc', 'asctk', 'asckt', 
'asktc', 'askct', 'atsck', 'atskc', 'atcsk', 'atcks', 'atksc', 'atkcs', 'acstk', 
'acskt', 'actsk', 'actks', 'ackst', 'ackts', 'akstc', 'aksct', 'aktsc', 'aktcs', 
'akcst', 'akcts', 'cstak', 'cstka', 'csatk', 'csakt', 'cskta', 'cskat', 'ctsak', 
'ctska', 'ctask', 'ctaks', 'ctksa', 'ctkas', 'castk', 'caskt', 'catsk', 'catks', 
'cakst', 'cakts', 'cksta', 'cksat', 'cktsa', 'cktas', 'ckast', 'ckats', 'kstac', 
'kstca', 'ksatc', 'ksact', 'kscta', 'kscat', 'ktsac', 'ktsca', 'ktasc', 'ktacs', 
'ktcsa', 'ktcas', 'kastc', 'kasct', 'katsc', 'katcs', 'kacst', 'kacts', 'kcsta', 
'kcsat', 'kctsa', 'kctas', 'kcast', 'kcats']
    120
    120
    [Finished in 0.3s]

5
नहीं, आपको हमेशा डुप्लिकेट (या बदतर) मिलते हैं यदि आपके पास दो या अधिक समान पत्र हैं। यह @ मशीनगेटिंग के उदाहरण में मामला था, क्योंकि उन्होंने स्टैक के बजाय स्टैक शब्द का उपयोग किया था । इसका मतलब है कि: आपका समाधान केवल अद्वितीय वर्णों वाले शब्दों के लिए काम करता है।
इरिक

2
def permute(seq):
    if not seq:
        yield seq
    else:
        for i in range(len(seq)):
            rest = seq[:i]+seq[i+1:]
            for x in permute(rest):
                yield seq[i:i+1]+x

print(list(permute('stack')))

2
क्या आप बता सकते हैं कि आपका समाधान पहले से उपलब्ध कराए गए लोगों से बेहतर क्यों है?
नोएल विडमर

मैंने यह नहीं कहा कि मेरा समाधान दूसरों से बेहतर है। मैंने बस ऐसा करने के लिए अपना समाधान प्रदान किया।
श्रीवास्तव

1

4
संयोजन उसकी समस्या के लिए प्रासंगिक नहीं है। वह पत्रों को स्थानांतरित कर रहा है, जिसका अर्थ है कि आदेश प्रासंगिक है, जिसका अर्थ है केवल क्रमपरिवर्तन
मशीन

1

इटरूल का उपयोग किए बिना, अलग-अलग वर्णों के साथ स्ट्रिंग के सभी क्रमपरिवर्तन की सूची वापस करने के लिए इल्यूकस के कोड में थोड़ा सुधार हुआ है s(आवश्यक रूप से लेक्सिकोग्राफ़िक क्रम में नहीं)।

def get_perms(s, i=0):
    """
    Returns a list of all (len(s) - i)! permutations t of s where t[:i] = s[:i].
    """
    # To avoid memory allocations for intermediate strings, use a list of chars.
    if isinstance(s, str):
        s = list(s)

    # Base Case: 0! = 1! = 1.
    # Store the only permutation as an immutable string, not a mutable list.
    if i >= len(s) - 1:
        return ["".join(s)]

    # Inductive Step: (len(s) - i)! = (len(s) - i) * (len(s) - i - 1)!
    # Swap in each suffix character to be at the beginning of the suffix.
    perms = get_perms(s, i + 1)
    for j in range(i + 1, len(s)):
        s[i], s[j] = s[j], s[i]
        perms.extend(get_perms(s, i + 1))
        s[i], s[j] = s[j], s[i]
    return perms

1

फिर भी एक और पहल और पुनरावर्ती समाधान। विचार एक पत्र को एक धुरी के रूप में चुनना है और फिर एक शब्द बनाना है।

# for a string with length n, there is a factorial n! permutations
alphabet = 'abc'
starting_perm = ''
# with recursion
def premuate(perm, alphabet):
    if not alphabet: # we created one word by using all letters in the alphabet
        print(perm + alphabet)
    else:
        for i in range(len(alphabet)): # iterate over all letters in the alphabet
            premuate(perm + alphabet[i], alphabet[0:i] + alphabet[i+1:]) # chose one letter from the alphabet

# call it            
premuate(starting_perm, alphabet)

आउटपुट:

abc
acb
bac
bca
cab
cba

0

यहाँ एक बहुत ही सरल जनरेटर संस्करण है:

def find_all_permutations(s, curr=[]):
    if len(s) == 0:
        yield curr
    else:
        for i, c in enumerate(s):
            for combo in find_all_permutations(s[:i]+s[i+1:], curr + [c]):
                yield "".join(combo)

मुझे लगता है कि यह इतना बुरा नहीं है!



0

यहाँ एक सरल और सीधा पुनरावर्ती कार्यान्वयन है;

def stringPermutations(s):
    if len(s) < 2:
        yield s
        return
    for pos in range(0, len(s)):
        char = s[pos]
        permForRemaining = list(stringPermutations(s[0:pos] + s[pos+1:]))
        for perm in permForRemaining:
            yield char + perm

1
आपको इंडेंटेशन को ठीक करना चाहिए। stringPermutationsकिसी सूची में पुनरावर्ती कॉल के परिणामों को सहेजने की कोई आवश्यकता नहीं है - आप सीधे इसे खत्म कर सकते हैं, जैसे for perm in stringPermutations(s[:pos] + s[pos+1:]):। इसके अलावा, आप इसके बजाय का forउपयोग करके लूप को सरल बना सकते enumerateहैं range, और char = s[pos]असाइनमेंट को समाप्त कर सकते हैं for pos, char in enumerate(s)::।
PM 2Ring


0
def perm(string):
   res=[]
   for j in range(0,len(string)):
       if(len(string)>1):
           for i in perm(string[1:]):
               res.append(string[0]+i)
       else:
           return [string];
       string=string[1:]+string[0];
   return res;
l=set(perm("abcde"))

यह पुनरावृत्ति के साथ क्रमपरिवर्तन उत्पन्न करने का एक तरीका है, आप कोड को 'ए', 'एब' और 'एबीसी' इनपुट के रूप में आसानी से समझ सकते हैं।

आप सभी एन! डुप्लिकेट के बिना, इस के साथ क्रमपरिवर्तन।


0

हर कोई अपने स्वयं के कोड की गंध प्यार करता है। सिर्फ एक साझा करना जो मुझे सबसे सरल लगता है:

def get_permutations(word):
    if len(word) == 1:
        yield word

    for i, letter in enumerate(word):
        for perm in get_permutations(word[:i] + word[i+1:]):
            yield letter + perm

0

यह कार्यक्रम डुप्लिकेट को समाप्त नहीं करता है, लेकिन मुझे लगता है कि यह सबसे कुशल दृष्टिकोणों में से एक है:

s=raw_input("Enter a string: ")
print "Permutations :\n",s
size=len(s)
lis=list(range(0,size))
while(True):
    k=-1
    while(k>-size and lis[k-1]>lis[k]):
        k-=1
    if k>-size:
        p=sorted(lis[k-1:])
        e=p[p.index(lis[k-1])+1]
        lis.insert(k-1,'A')
        lis.remove(e)
        lis[lis.index('A')]=e
        lis[k:]=sorted(lis[k:])
        list2=[]
        for k in lis:
                list2.append(s[k])
        print "".join(list2)
    else:
                break

0
def permute_all_chars(list, begin, end):

    if (begin == end):
        print(list)
        return

    for current_position in range(begin, end + 1):
        list[begin], list[current_position] = list[current_position], list[begin]
        permute_all_chars(list, begin + 1, end)
        list[begin], list[current_position] = list[current_position], list[begin]


given_str = 'ABC'
list = []
for char in given_str:
    list.append(char)
permute_all_chars(list, 0, len(list) -1)

कृपया कुछ विवरण जोड़ने का प्रयास करें।
अरुण विनोथ

0

क्रमपरिवर्तन का उपयोग करते हुए सरल समाधान।

from itertools import permutations

def stringPermutate(s1):
    length=len(s1)
    if length < 2:
        return s1

    perm = [''.join(p) for p in permutations(s1)]

    return set(perm)

0

ढेर के साथ सभी संभव शब्द

from itertools import permutations
for i in permutations('stack'):
    print(''.join(i))
permutations(iterable, r=None)

पुनरावृत्ति की पुनरावृत्ति तत्वों में तत्वों की लंबाई क्रमपरिवर्तन।

यदि आर निर्दिष्ट नहीं है या कोई भी नहीं है, तो पुनरावृत्त की लंबाई तक चलने योग्य और सभी संभव पूर्ण-लंबाई क्रमपरिवर्तन उत्पन्न होते हैं।

क्रमबद्धता को शाब्दिक क्रम में उत्सर्जित किया जाता है। इसलिए, यदि इनपुट पुनरावृत्त क्रमबद्ध है, तो क्रमबद्ध क्रम में टुपल्स का उत्पादन किया जाएगा।

तत्वों को उनकी स्थिति के आधार पर अद्वितीय माना जाता है, उनके मूल्य पर नहीं। इसलिए यदि इनपुट तत्व अद्वितीय हैं, तो प्रत्येक क्रमपरिवर्तन में कोई दोहराव नहीं होगा।


0

यह एक पुनरावर्ती समाधान है n!जिसके साथ स्ट्रिंग में डुप्लिकेट तत्वों को स्वीकार करता है

import math

def getFactors(root,num):
    sol = []
    # return condition
    if len(num) == 1:
            return [root+num]
    # looping in next iteration
    for i in range(len(num)):  
        # Creating a substring with all remaining char but the taken in this iteration
        if i > 0:
            rem = num[:i]+num[i+1:]
        else:
            rem = num[i+1:]
        # Concatenating existing solutions with the solution of this iteration
        sol = sol + getFactors(root + num[i], rem)
    return sol

मैंने दो तत्वों को ध्यान में रखते हुए समाधान को मान्य किया, संयोजनों की संख्या है n!और परिणाम में डुप्लिकेट शामिल नहीं हो सकते हैं। इसलिए:

inpt = "1234"
results = getFactors("",inpt)

if len(results) == math.factorial(len(inpt)) | len(results) != len(set(results)):
    print("Wrong approach")
else:
    print("Correct Approach")

0

पुनरावर्ती दृष्टिकोण के साथ।

def permute(word):
    if len(word) == 1:
        return [word]
    permutations = permute(word[1:])
    character = word[0]
    result = []
    for p in permutations:
        for i in range(len(p)+1):
            result.append(p[:i] + character + p[i:])
    return result




running code.

>>> permute('abc')
['abc', 'bac', 'bca', 'acb', 'cab', 'cba']

-1

पुनर्मिलन के साथ

# swap ith and jth character of string
def swap(s, i, j):
    q = list(s)
    q[i], q[j] = q[j], q[i]
    return ''.join(q)


# recursive function 
def _permute(p, s, permutes):
    if p >= len(s) - 1:
        permutes.append(s)
        return

    for i in range(p, len(s)):
        _permute(p + 1, swap(s, p, i), permutes)


# helper function
def permute(s):
    permutes = []
    _permute(0, s, permutes)
    return permutes


# TEST IT
s = "1234"
all_permute = permute(s)
print(all_permute)

Iterative दृष्टिकोण के साथ (स्टैक का उपयोग करके)

# swap ith and jth character of string
def swap(s, i, j):
    q = list(s)
    q[i], q[j] = q[j], q[i]
    return ''.join(q)


# iterative function
def permute_using_stack(s):
    stk = [(0, s)]

    permutes = []

    while len(stk) > 0:
        p, s = stk.pop(0)

        if p >= len(s) - 1:
            permutes.append(s)
            continue

        for i in range(p, len(s)):
            stk.append((p + 1, swap(s, p, i)))

    return permutes


# TEST IT
s = "1234"
all_permute = permute_using_stack(s)
print(all_permute)

लेक्सोग्राफिक रूप से छाँटे गए

# swap ith and jth character of string
def swap(s, i, j):
    q = list(s)
    q[i], q[j] = q[j], q[i]
    return ''.join(q)


# finds next lexicographic string if exist otherwise returns -1
def next_lexicographical(s):
    for i in range(len(s) - 2, -1, -1):
        if s[i] < s[i + 1]:
            m = s[i + 1]
            swap_pos = i + 1

            for j in range(i + 1, len(s)):
                if m > s[j] > s[i]:
                    m = s[j]
                    swap_pos = j

            if swap_pos != -1:
                s = swap(s, i, swap_pos)
                s = s[:i + 1] + ''.join(sorted(s[i + 1:]))
                return s

    return -1


# helper function
def permute_lexicographically(s):
    s = ''.join(sorted(s))
    permutes = []
    while True:
        permutes.append(s)
        s = next_lexicographical(s)
        if s == -1:
            break
    return permutes


# TEST IT
s = "1234"
all_permute = permute_lexicographically(s)
print(all_permute)
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.