Distinct permutations of the string | Set 2
Last Updated :
05 Feb, 2025
Given a string s, the task is to return all unique permutations of a given string in lexicographically sorted order.
Note: A permutation is the rearrangement of all the elements of a string.
Examples:
Input: s = "ABC"
Output: "ABC", "ACB", "BAC", "BCA", "CBA", "CAB"
Input: s = "XY"
Output: "XY", "YX"
Input: s = "AAA"
Output: "AAA"
Approach:
The idea is to use backtracking to generate all possible permutations of given string s. To do so, first initialise an array of string ans[] to list all the permutations and a HashSet res to store all the unique strings in lexicographically sorted order.Start from the 0th index and for each index i, swap the value s[i] with all the elements in its right i.e. from i+1 to n-1, and recur to the index i + 1. If the index i is equal to n, store the resultant string in res, else keep operating similarly for all other indices. Thereafter, swap back the values to original values to initiate backtracking. At last insert the elements in array ans[].
Recursion Tree for permutations of string "ABC"Below is the implementation of the above approach:
C++
// C++ Program to generate all unique
// permutations of a string
#include <bits/stdc++.h>
using namespace std;
// Recursive function to generate
// all permutations of string s
void recurPermute(int index, string &s,
set<string> &ans) {
// Base Case
if (index == s.size()) {
ans.insert(s);
return;
}
// Swap the current index with all
// possible indices and recur
for (int i = index; i < s.size(); i++) {
swap(s[index], s[i]);
recurPermute(index + 1, s, ans);
swap(s[index], s[i]);
}
}
// Function to find all unique permutations
vector<string> findPermutation(string &s) {
// sort input string
sort(s.begin(), s.end());
// Stores the final answer
vector<string> ans;
// Stores all unique permutations
set<string> res;
recurPermute(0, s, res);
// Copy all unique permutations
// to the final answer
for (auto x : res) {
ans.push_back(x);
}
return ans;
}
int main() {
string s = "ABC";
vector<string> res = findPermutation(s);
for(auto x: res) {
cout << x << " ";
}
return 0;
}
// Java Program to generate all unique
// permutations of a string
import java.util.*;
class GfG {
// Recursive function to generate
// all permutations of string s
static void recurPermute(int index, StringBuilder s,
Set<String> ans) {
// Base Case
if (index == s.length()) {
ans.add(s.toString());
return;
}
// Swap the current index with all
// possible indices and recur
for (int i = index; i < s.length(); i++) {
char temp = s.charAt(index);
s.setCharAt(index, s.charAt(i));
s.setCharAt(i, temp);
recurPermute(index + 1, s, ans);
temp = s.charAt(index);
s.setCharAt(index, s.charAt(i));
s.setCharAt(i, temp);
}
}
// Function to find all unique permutations
static List<String> findPermutation(String s) {
// sort input string
char[] sorted = s.toCharArray();
Arrays.sort(sorted);
s = new String(sorted);
// Stores the final answer
List<String> ans = new ArrayList<>();
// Stores all unique permutations
Set<String> res = new TreeSet<>();
recurPermute(0, new StringBuilder(s), res);
// Copy all unique permutations
// to the final answer
ans.addAll(res);
return ans;
}
public static void main(String[] args) {
String s = "ABC";
List<String> res = findPermutation(s);
for (String x : res) {
System.out.print(x + " ");
}
}
}
# Python Program to generate all unique
# permutations of a string
# Recursive function to generate
# all permutations of string s
def recurPermute(index, s, ans):
# Base Case
if index == len(s):
ans.add("".join(s))
return
# Swap the current index with all
# possible indices and recur
for i in range(index, len(s)):
s[index], s[i] = s[i], s[index]
recurPermute(index + 1, s, ans)
s[index], s[i] = s[i], s[index]
# Function to find all unique permutations
def findPermutation(s):
# sort input string
s = "".join(sorted(s))
# Stores all unique permutations
res = set()
recurPermute(0, list(s), res)
# Convert set to list for the final answer
return sorted(list(res))
if __name__ == "__main__":
s = "ABC"
res = findPermutation(s)
print(" ".join(res))
// C# Program to generate all unique
// permutations of a string
using System;
using System.Collections.Generic;
class GfG {
// Recursive function to generate
// all permutations of string s
static void recurPermute(int index, char[] s,
SortedSet<string> ans) {
// Base Case
if (index == s.Length) {
ans.Add(new string(s));
return;
}
// Swap the current index with all
// possible indices and recur
for (int i = index; i < s.Length; i++) {
char temp = s[index];
s[index] = s[i];
s[i] = temp;
recurPermute(index + 1, s, ans);
temp = s[index];
s[index] = s[i];
s[i] = temp;
}
}
// Function to find all unique permutations
static List<string> findPermutation(string s) {
// sort input string
char[] sorted = s.ToCharArray();
Array.Sort(sorted);
s = new string(sorted);
// Stores the final answer
List<string> ans = new List<string>();
// Stores all unique permutations
SortedSet<string> res = new SortedSet<string>();
recurPermute(0, s.ToCharArray(), res);
// Copy all unique permutations
// to the final answer
ans.AddRange(res);
return ans;
}
static void Main(string[] args) {
string s = "ABC";
List<string> res = findPermutation(s);
foreach (string x in res) {
Console.Write(x + " ");
}
}
}
// JavaScript Program to generate all unique
// permutations of a string
// Recursive function to generate
// all permutations of string s
function recurPermute(index, s, ans) {
// Base Case
if (index === s.length) {
ans.add(s.join(""));
return;
}
// Swap the current index with all
// possible indices and recur
for (let i = index; i < s.length; i++) {
[s[index], s[i]] = [s[i], s[index]];
recurPermute(index + 1, s, ans);
[s[index], s[i]] = [s[i], s[index]];
}
}
// Function to find all unique permutations
function findPermutation(s) {
// sort input string
s = s.split("").sort();
// Stores all unique permutations
let res = new Set();
recurPermute(0, s, res);
// Convert Set to Array for the final answer
return Array.from(res).sort();
}
//Driver code
const s = "ABC";
const res = findPermutation(s);
console.log(res.join(" "));
OutputABC ACB BAC BCA CAB CBA
Time Complexity: O(n * n!)
Auxiliary Space: O(n!)
Note: The given problem can also solved using Recursion and STL. These approaches are discussed in below given articles:
Similar Reads
Permutations of a given string using STL Given a string s, the task is to return all unique permutations of a given string in lexicographically sorted order.Note: A permutation is the rearrangement of all the elements of a string.Examples:Input: s = "ABC"Output: "ABC", "ACB", "BAC", "BCA", "CBA", "CAB"Input: s = "XY"Output: "XY", "YX"Input
4 min read
Print all Unique permutations of a given string. Given a string that may contain duplicates, the task is find all unique permutations of given string in any order.Examples: Input: "ABC"Output: ["ABC", "ACB", "BAC", "BCA", "CAB", "CBA"]Explanation: Given string ABC has 6 unique permutations as "ABC", "ACB", "BAC", "BCA", "CAB" and "CBA".Input: "AAA
12 min read
Print all permutations of a string in Java Given a string str, the task is to print all the permutations of str. A permutation is an arrangement of all or part of a set of objects, with regard to the order of the arrangement. For instance, the words ‘bat’ and ‘tab’ represents two distinct permutation (or arrangements) of a similar three lett
3 min read
Print first n distinct permutations of string using itertools in Python Given a string with duplicate characters allowed, print first n permutations of given string such that no permutation is repeated. Examples: Input : string = "abcab", n = 10 Output : aabbc aabcb aacbb ababc abacb abbac abbca abcab abcba acabb Input : string = "okok", n = 4 Output : kkoo koko kook ok
2 min read
Python | Permutation of a given string using inbuilt function The task is to generate all the possible permutations of a given string. A permutation of a string is a rearrangement of its characters. For example, the permutations of "ABC" are "ABC", "ACB", "BAC", "BCA", "CAB", and "CBA". The number of permutations of a string with n unique characters is n! (fac
2 min read