Python Tutorial

In this tutorial, we will write the Python program to find a permutation of the given string. The problem is a given string S, we need to find all unique permutations of the given string in lexicographically sorted order. Below is an example -

Example - 1:

Input: ABC

Output:
ABC ACB BAC BCA CAB CBA

Explanation:
Given string ABC has permutations in 6 
forms as ABC, ACB, BAC, BCA, CAB and CBA 

Example - 2:

Input: ABSG

Output:
ABGS ABSG AGBS AGSB ASBG ASGB BAGS 
BASG BGAS BGSA BSAG BSGA GABS GASB 
GBAS GBSA GSAB GSBA SABG SAGB SBAG 
SBGA SGAB SGBA

Explanation:
Given string ABSG has 24 permutations.

Solution

We will solve this problem using the recursive backtracking approach. Let's understand the following code snippet.

Example -

def unique_permutations(string):
    # Convert the string to a list of characters
    chars = list(string)
    # Sort the characters in lexicographic order
    chars.sort()
    
    # Create a list to store the permutations
    result = []
    
    # Define a recursive function to generate permutations
    def backtrack(start):
        # If the start index reaches the end of the string,
        # It means we have a valid permutation, so add it to the result
        if start == len(chars):
            result.append(''.join(chars))
        
        # Iterate from the start index to the end of the string
        for i in range(start, len(chars)):
            # Skip if the current character is the same as the previous character
            if i != start and chars[i] == chars[start]:
                continue
            
            # Swap the characters at the start and current indices
            chars[start], chars[i] = chars[i], chars[start]
            
            # Recursively generate permutations for the remaining characters
            backtrack(start + 1)
            
            # Restore the original order by swapping back the characters
            chars[start], chars[i] = chars[i], chars[start]
    
    # Call the backtrack function to start generating permutations
    backtrack(0)
    
    return result

# Example usage
string = "ABC"
permutations = unique_permutations(string)
for permutation in permutations:
    print(permutation)

Output:

ABC
ACB
BAC
BCA
CAB
CBA

Explanation -

In the above code, we define a unique_permutations() function takes this string, converts it into a list of characters, sorts them in lexicographic order, and then uses a recursive backtracking approach to generate all unique permutations. The permutations are stored in the result list and returned as the final output.

Method - 2:

In this method, we will use the itertools library and set data structure.

Example -

import itertools

def unique_permutations(string):
    # Generate all permutations of the string
    perms = itertools.permutations(string)
    # Use a set to remove duplicates and sort the permutations
    unique_perms = sorted(set(perms))
    
    # Print each unique permutation
    for perm in unique_perms:
        print(''.join(perm))
string = "ABC"
print(unique_permutations(string))

Output:

ABC
ACB
BAC
BCA
CAB
CBA

Explanation -

In this implementation, the itertools.permutations function is used to generate all possible permutations of the given string. The permutations are then passed to the set function to eliminate duplicates, and finally sorted to ensure lexicographic order. Each unique permutation is printed using the print statement.

Method - 3:

In this method, we utilizes a combination of itertools and functools libraries to solve the problem. Let's understand the following example.

Example -

import itertools
import functools

def compare_permutations(perm1, perm2):
    # Concatenate the permutations in different orders
    order1 = perm1 + perm2
    order2 = perm2 + perm1

    # Compare the concatenated permutations lexicographically
    if order1 < order2:
        return -1
    elif order1 > order2:
        return 1
    else:
        return 0

def unique_permutations(string):
    # Generate all permutations of the string
    perms = itertools.permutations(string)
    # Sort the permutations using custom comparison function
    sorted_perms = sorted(perms, key=functools.cmp_to_key(compare_permutations))
    
    # Convert permutations to strings
    unique_perms = [''.join(perm) for perm in sorted_perms]
    
    return unique_perms

# Example usage
string = "ABC"
permutations = unique_permutations(string)
for permutation in permutations:
    print(permutation)

Output -

In this solution, the unique_permutations() function uses the itertools.permutations() function to generate all possible permutations of the given string. The permutations are then sorted using the sorted function and a custom comparison function compare_permutations(). The compare_permutations() function compares two permutations by concatenating them in different orders and comparing the resulting strings lexicographically.

The functools.cmp_to_key() function is used to convert the comparison function to a key function suitable for sorting. Finally, the sorted permutations are converted back to strings and returned as the result.

Method - 4:

To get all unique permutations of a given string in lexicographically sorted order, we will use a recursive approach with memoization. This approach can help avoid redundant computations and improve efficiency. Let's understand the following example.

Example -

def unique_permutations(string):
    # Create a dictionary to store already computed permutations
    memo = {}
    
    # Define a recursive function to generate permutations
    def generate_permutations(remaining):
        # Base case: If there is only one character remaining,
        # return a list with that character as the only permutation
        if len(remaining) == 1:
            return [remaining]
        
        # Check if the permutations for the remaining characters have already been computed
        if remaining in memo:
            return memo[remaining]
        
        permutations = []
        
        # Generate permutations by fixing each character at the beginning
        for i in range(len(remaining)):
            fixed_char = remaining[i]
            # Exclude the fixed character from the remaining characters
            remaining_chars = remaining[:i] + remaining[i+1:]
            
            # Recursively generate permutations for the remaining characters
            sub_permutations = generate_permutations(remaining_chars)
            
            # Append the fixed character to each sub-permutation
            for sub_permutation in sub_permutations:
                permutations.append(fixed_char + sub_permutation)
        
        # Store the computed permutations in the memoization dictionary
        memo[remaining] = permutations
        
        return permutations
    
    # Call the recursive function to generate permutations
    all_permutations = generate_permutations(string)
    
    # Sort the permutations in lexicographic order
    sorted_permutations = sorted(all_permutations)
    
    return sorted_permutations

# Example usage
string = "ABC"
permutations = unique_permutations(string)
for permutation in permutations:
    print(permutation)

Output:

ABC
ACB
BAC
BCA
CAB
CBA

Explanation -

In this implementation, the unique_permutations() function takes the string and uses a recursive function generate_permutations() to generate all unique permutations. The function recursively fixes each character at the beginning and generates permutations for the remaining characters. Memoization is used to store already computed permutations to avoid redundant computations.

The computed permutations are then sorted in lexicographic order using the sorted function. Finally, the sorted permutations are returned as the result.

This method with memoization offers an alternative solution that reduces computation time by avoiding duplicate calculations.

Next TopicWrite the Python Program to Sort an Array According to Other

← prev next →