পাইথনে প্রদত্ত স্ট্রিংয়ের সমস্ত সম্ভাব্য ক্রমশক্তি সন্ধান করা


93

আমার একটা স্ট্রিং আছে আমি এই স্ট্রিং থেকে অক্ষরের ক্রম পরিবর্তন করে সমস্ত ক্রম তৈরি করতে চাই। উদাহরণস্বরূপ, বলুন:

x='stack'

আমি যা চাই তা এই জাতীয় একটি তালিকা,

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

বর্তমানে আমি স্ট্রিংয়ের তালিকার তালিকায় পুনরাবৃত্তি করছি, এলোমেলোভাবে 2 টি অক্ষর বাছাই করেছি এবং একটি নতুন স্ট্রিং তৈরি করতে এগুলি ট্রান্সপোজ করছি এবং এটিকে l এর কাস্ট সেট করতে যুক্ত করব। স্ট্রিংয়ের দৈর্ঘ্যের উপর ভিত্তি করে, আমি নির্ধারিত আকারের সীমাতে পৌঁছাবার আগে পর্যন্ত সম্ভাব্য ক্রম সংখ্যা এবং অবিরত পুনরাবৃত্তিগুলি গণনা করছি। এটি করার আরও ভাল উপায় থাকতে হবে।

উত্তর:


148

ইটারটুলস মডিউলের একটি কার্যকর পদ্ধতি রয়েছে যা বলা হয় ক্রমানুস ()। নথি বলছে:

itertools.permutations (পুনরাবৃত্তিযোগ্য [, r])

পুনরাবৃত্তীয় উপাদানগুলির ক্রমাগত r দৈর্ঘ্যের ক্রম ফেরত দিন।

আর যদি নির্দিষ্ট না করা হয় বা কোনওটি না হয়, তবে পুনরাবৃত্তিযোগ্য দৈর্ঘ্যের ডিফল্ট এবং সমস্ত সম্ভাব্য পূর্ণ দৈর্ঘ্যের ক্রম উত্পন্ন হয়।

পেরুকেশনগুলি লিক্সোগ্রাফিক সাজানোর ক্রমে নির্গত হয়। সুতরাং, যদি ইনপুট পুনরাবৃত্তিযোগ্য বাছাই করা হয়, ক্রমান্বকরণ টিপলগুলি সাজানো ক্রমে উত্পাদিত হবে।

যদিও আপনার অনুমতিপ্রাপ্ত অক্ষরগুলিকে স্ট্রিং হিসাবে যোগদান করতে হবে।

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

['স্ট্যাক', 'স্টাক্ক', 'স্ট্যাকাক', 'স্ট্যাকা', 'স্টটক্যাক', 'স্টক্কা', 'স্যাট', 'স্যাটাক', 'স্যাক্ট', 'শট', 'স্যাক্ট', 'স্যাক্ট', ' স্ক্যাকট ',' স্ক্যাক্টা ',' স্কেচ ',' স্ক্যাক্ট ',' স্ক্যাক্টা ',' স্ক্যাকট ',' স্কট্যাক ',' স্ক্টকা ',' স্ক্যাট্যাক ',' স্ক্যাক্ট ',' স্ক্যাক্টা ',' স্ক্যাক্যাট ',' tsack ' , 'tsakc', 'tscak', 'tscka', 'tskac', 'tscca', 'Tasck', 'Tascc', '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 ',' atks ',' atksc ',' atkcs ',' acstk ',' acskt ' , 'অ্যাক্টস্ক', 'অ্যাক্টস', 'অ্যাকসিস্ট', 'আকটস', 'আকসটসি', 'আকস্যাক্ট', 'আকটস্যাক', 'আকটসিএস', 'একসিএসটি', 'আকটস', 'সিএসটিএক', 'সিএসটিএ', ' csatk ',' csakt ',' cskta ',' cskat ',' ctsak ',' ctska ',' ctask ',' ctaks ',' ctksa ',' ctkas ',' castk ',' caskt ',' catsk ' , 'ক্যাটস', 'ক্যাকস্ট', 'ক্যাকটস', 'সেকস্টা', 'ক্যাকস্যাট', 'স্যাকটাসা', 'সেকটাস', 'সিসকাট', 'সিএকেটস', 'কেস্ট্যাক', 'কেএসটিএ', 'ক্যাস্যাট','কেস্যাক্ট', 'কেএসটিএ', 'কেএসকেট', 'কেটস্যাক', 'কেটসকা', 'কেটাস্ক', 'কেট্যাক্স', 'কেটিসিএসএ', 'কেটস', 'ক্যাসট', 'ক্যাসট', 'কাটস্যাক', 'কেটস্যাক' ',' ক্যাকস্ট ',' কেট্যাকস ',' কেসিস্টা ',' কেসিএস্যাট ',' কেসিটিএসএ ',' কেসিটিএস ',' ক্যাসকেট ',' কেসিটিস ']

যদি আপনি ডুপ্লিকেট দ্বারা নিজেকে সমস্যায় ফেলেছেন তবে কোনও ডুপ্লিকেট ছাড়াই কোনও কাঠামোর সাথে আপনার ডেটা ফিট করার চেষ্টা করুন set:

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

@ পিএসটি এর প্রতি ইঙ্গিত করার জন্য ধন্যবাদ যে আমরা .তিহ্যগতভাবে টাইপ কাস্ট হিসাবে ভাবতে চাই না, তবে set()কনস্ট্রাক্টরের কাছে আরও একটি কল ।


4
নিত: set(...)"কাস্ট" করে না। বরং এটি ইনপুট সংগ্রহকে উপস্থাপন করে এমন সেট তৈরি করে (এবং ফলন দেয়): একবার উত্পন্ন হয়েছিল এর ইনপুট সংগ্রহের সাথে কোনও সম্পর্ক নেই (এবং এটি একটি পৃথক বস্তু, কেবল একটি ভিন্ন দৃষ্টিভঙ্গি নয়))।

@ পিএসটি: হুম আমি দ্বিমত পোষণ করব। আমি অ্যাডা বা পাসকালে জানি যে castালাই একই বিটগুলিতে কেবল একটি নতুন টাইপ-ভিউ। তবে কমপক্ষে কোনও সি দৃষ্টিকোণ থেকে, আপনি তথ্যের অন্তর্নিহিত কাঠামো পরিবর্তন করছেন কিনা তা নিক্ষেপণ একটি উপযুক্ত শব্দ। এটি কেবল সুস্পষ্ট ধরণের রূপান্তর বোঝায়। পারলে দয়া করে আমার ভুল বোঝাবুঝির ব্যাখ্যা করুন।
মেশিন আকাঙ্ক্ষিত

4
টাইপকাস্টিং । আপনি যেমন উল্লেখ করেছেন, এটি নিছক দৃষ্টিভঙ্গির চেয়ে পৃথক হতে পারে, তবে আমি বিভ্রান্তি এড়াতে ধারণাগুলি পৃথক করে দেখতে চেষ্টা করতে চাই। আমার প্রথম মন্তব্যে আমার "জবরদস্তি" স্পষ্টভাবে উল্লেখ করা উচিত ছিল, যদিও আমি কেবল একটি ফাংশন সেট: তালিকা -> সেট বিবেচনা করব।

4
আমি এটি দেখতে, bool এমন একটি ফাংশন যা ইনপুটটির উপর নির্ভর করে একটি বুল (সত্য / মিথ্যা) মূল্যায়ন করে । আমি এখানে "কাস্ট"

4
একটি আকর্ষণীয় আপডেট হিসাবে ডকুমেন্টেশনটি তখন থেকেই বিল্ট-ইন ফাংশন বুল () ব্যবহার করে কোনও মান বুলিয়ান রূপান্তর করতে ব্যবহার করা যেতে পারে , বিশেষভাবে কাস্টের পরিবর্তে । এই আলোচনার পরবর্তী প্রকাশে এটি ঘটেছিল, আমাকে বিশ্বাস করতে পরিচালিত করে যে এই আলোচনা ডক্সে পরিবর্তনের দিকে নিয়ে যায়!
মেশিনটি

46

আপনি সব এন পেতে পারেন! অনেক কোড ছাড়া ক্রম

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

4
আমি কেবল এটি সামান্য পরিবর্তিত করেছি, i == পদক্ষেপ
work_in_progress

4
রানটাইমটি ও (এন!) হওয়ায় এন রয়েছে! ক্রম।
অ্যাস্পেন

আপনি step == len(string)পরিবর্তে ব্যবহার করছেন কেন step == len(string) - 1?
tulians

কারণ তখন সর্বশেষ 2 টি আইটেম কখনও অদলবদল হবে না। খ এবং সি অদলবদল হওয়া অবধি 'এবিসি' ব্যবহার করে দেখুন।
রোমান রিসেন

16

এখানে ন্যূনতম কোড সহ স্ট্রিংয়ের ক্রিয়াকলাপ করার আরও একটি উপায়। আমরা মূলত একটি লুপ তৈরি করি এবং তারপরে আমরা একবারে দুটি অক্ষর অদলবদল করি, লুপের ভিতরে আমাদের পুনরাবৃত্তি হবে। লক্ষ্য করুন, আমরা কেবল তখনই মুদ্রণ করি যখন সূচকগুলি আমাদের স্ট্রিংয়ের দৈর্ঘ্যে পৌঁছায়। উদাহরণ: আমাদের শুরুর পয়েন্টের জন্য এবিসি আই এবং আমাদের লুপের জন্য আমাদের পুনরাবৃত্তি পরম জে

এখানে কীভাবে এটি বাম থেকে ডানদিক থেকে নীচে অবধি কার্যকরভাবে দৃশ্যমান সহায়তা (ক্রমানুসারে ক্রম হয়)

এখানে চিত্র বর্ণনা লিখুন

কোড :

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)

4
এটি উল্লেখ করা সহায়ক হতে পারে যে এটি বাইট্যাকিংয়ের দৃষ্টান্তের ভিত্তি ।
অরুণিআরসি

আরও তথ্য, একই / অনুরূপ কোড: geeksforgeeks.org/… আমি গ্রাফিক উদাহরণ সহ আপনার উদাহরণটি আরও ভাল পছন্দ করি;)
সিটিএস_এইই

8

স্ট্যাক ওভারফ্লো ব্যবহারকারীরা ইতিমধ্যে কিছু শক্ত সমাধান পোস্ট করেছেন তবে আমি আরও একটি সমাধান দেখাতে চেয়েছিলাম। এটি আমি আরও স্বজ্ঞাত বলে মনে করি

ধারণাটি একটি নির্দিষ্ট স্ট্রিংয়ের জন্য: আমরা অ্যালগরিদম (সিউডো-কোড) দ্বারা পুনরাবৃত্তি করতে পারি:

স্ট্রুমে চরের জন্য ক্রমজাতকরণ = চর + ক্রমান্বন (স্ট্রিং - চর)

আমি আশা করি এটি কাউকে সাহায্য করবে!

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
পুনরাবৃত্তি করা অক্ষর (স্ট্রিয়র রিপ্লেসেস) এমন ক্ষেত্রে এটি কাজ করবে না। যেমন: rqqx
sanjay

ব্যবহার করুন: [অনুমোদন_লিস্ট.এপেন্ড করুন (চার + এ) অনুমানের জন্য (স্ট্রিং.রেপ্লেস (চর, "", 1))]
ব্যবহারকারী 3761855

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। ২. এটি recursive_permsরিটার্নের বিবৃতিতে কোনও সেটকে রূপান্তরিত করে এমন তালিকার পরিবর্তে একটি সেট থাকলে র্যাম এবং সময় সাশ্রয় করবে । ৩. .replaceপুনরাবৃত্তির কলটিতে আরগটি তৈরির পরিবর্তে স্ট্রিং স্লাইসিং ব্যবহার করা আরও দক্ষ হবে permutations। ৪. stringপরিবর্তনশীল নাম হিসাবে ব্যবহার করা ভাল ধারণা নয় কারণ এটি স্ট্যান্ডার্ড stringমডিউলটির নাম ছায়া দেয় ।
প্রধানমন্ত্রী 2Ring

5

এখানে @ অ্যাড্রিয়ানো এবং @ ইল্লিলুসিস যা পোস্ট করেছেন তার থেকে আলাদা একটি পদ্ধতি। এটির একটি ভাল রানটাইম রয়েছে, আপনি সময়টি পরিমাপ করে এটি যাচাই করতে পারেন:

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 সেকেন্ড এবং @ অ্যাড্রিয়ানো এবং @ ইলিরুসিস সংস্করণে 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')]

সুন্দরভাবে ব্যাখ্যা করা হয়েছে।
lmao

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]

4
না, আপনি যদি দুটি বা ততোধিক একই বর্ণ থাকে তবে আপনি সর্বদা সদৃশ (বা আরও খারাপ) পান। @ মেশিনইয়ারিংয়ের উদাহরণে এটি ছিল, কারণ তিনি স্ট্যাকের পরিবর্তে স্ট্যাক শব্দটি ব্যবহার করেছিলেন । এর অর্থ: আপনার সমাধানটি কেবল এর মধ্যে অনন্য অক্ষরযুক্ত শব্দের জন্য কাজ করে।
এরিক

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')))

4
আপনি কি ব্যাখ্যা করতে পারেন যে ইতিমধ্যে সরবরাহ করাগুলির চেয়ে আপনার সমাধান কেন ভাল?
নোয়েল ওয়াইডার

আমি বলিনি যে আমার সমাধান অন্যদের চেয়ে ভাল। আমি এটি করার জন্য আমার সমাধানটি সরবরাহ করেছি।
শ্রীবাস্তব

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

4
আপনার ইন্ডেন্টেশনটি ঠিক করা উচিত। stringPermutationsতালিকায় পুনরাবৃত্ত কলগুলির ফলাফলগুলি সংরক্ষণ করার দরকার নেই - আপনি সরাসরি এটির মাধ্যমে পুনরাবৃত্তি করতে পারেন, যেমন for perm in stringPermutations(s[:pos] + s[pos+1:]):। এছাড়াও, আপনি প্রক্রিয়া সহজ করতে forব্যবহার করে লুপ enumerateপরিবর্তে range, এবং নিষ্কাশন char = s[pos]নিয়োগ: for pos, char in enumerate(s):
প্রধানমন্ত্রী 2 রিং


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)

পুনরাবৃত্তীয় উপাদানগুলির ক্রমাগত r দৈর্ঘ্যের ক্রম ফেরত দিন।

আর যদি নির্দিষ্ট না করা হয় বা কোনওটি না হয়, তবে পুনরাবৃত্তিযোগ্য দৈর্ঘ্যের ডিফল্ট এবং সমস্ত সম্ভাব্য পূর্ণ দৈর্ঘ্যের ক্রম উত্পন্ন হয়।

পেরুকেশনগুলি লিক্সোগ্রাফিক সাজানোর ক্রমে নির্গত হয়। সুতরাং, যদি ইনপুট পুনরাবৃত্তিযোগ্য বাছাই করা হয়, ক্রমান্বকরণ টিপলগুলি সাজানো ক্রমে উত্পাদিত হবে।

উপাদানগুলি তাদের মান অনুযায়ী নয়, তাদের অবস্থানের ভিত্তিতে অনন্য হিসাবে বিবেচিত হয়। সুতরাং যদি ইনপুট উপাদানগুলি অনন্য হয় তবে প্রতিটি ক্রমান্বয়ে কোনও পুনরাবৃত্তি মান থাকবে না।


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)
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.