Distinct permutations of a number
Last Updated :
07 Dec, 2023
Given an integer N, the task is to print all distinct permutations of the number N.
Examples:
Input: N = 133
Output: 133 313 331
Explanation:
There are a total of 6 permutations, which are [133, 313, 331, 133, 313, 331].
Out of all these permutations, distinct permutations are [133, 313, 331].
Input: N = 7668
Output: 7668 7686 7866 6768 6786 6678 6687 6876 6867 8766 8676 8667
Approach: Follow the steps below to solve the problem:
- Initialize an empty string to store the equivalent string representation of N.
- Initialize a Map to convert each character of the string to an integer and store it as a list.
- Permute this list using built-in python functions itertools. permutations().
- Initialize another list, say newList.
- Traverse the permutations of the list and if the permutation(list) is not in newList then append this list to newList.
- Initialize an empty string, s = "" and another empty list say permuteList.
- Traverse the list newlist and for each list, perform the following operations:
- Print the values of permuteList as the possible distinct permutations.
Below is the implementation of the above approach:
C++
// C++ code to implement the approach
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
// Utility function to print all distinct permutations
void uniquePermutationsUtil(vector<string> permute)
{
vector<string> p;
// Traverse the list permute[]
for (string i : permute)
{
// Convert this permutation to list
p.push_back(i);
}
// Stores unique permutations
vector<string> newlist;
// Traverse list p[]
for (string i : p)
{
// If permutation is
// not in newlist
if (find(newlist.begin(), newlist.end(), i)
== newlist.end()) {
newlist.push_back(i);
}
}
// Initialize empty list
vector<int> permutelist;
// Traverse the list newlist[]
for (string i : newlist)
{
// Convert string to integer
int s = stoi(i);
// Append the unique
// permutation to permutelist
permutelist.push_back(s);
}
// Print all distinct permutations
for (int i : permutelist) {
cout << i << " ";
}
}
// Function to print all distinct permutations
void uniquePermutations(int N)
{
// Stores equivalent string
// representation of N
string num = to_string(N);
vector<char> lis(num.begin(), num.end());
vector<string> permute;
sort(lis.begin(), lis.end());
do {
permute.push_back(string(lis.begin(), lis.end()));
} while (next_permutation(lis.begin(), lis.end()));
// Print unique permutations
uniquePermutationsUtil(permute);
}
// Driver Code
int main()
{
// Given value of N
int N = 7668;
// Function call to find all distinct permutations of N
uniquePermutations(N);
return 0;
}
// This code is contributed by phasing17
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
class GFG {
// Utility function to print all distinct permutations
static void uniquePermutationsUtil(List<String> permute)
{
List<String> p = new ArrayList<>();
// Traverse the list permute[]
for (String i : permute) {
// Convert this permutation to list
p.add(i);
}
// Stores unique permutations
List<String> newList = new ArrayList<>();
// Traverse list p[]
for (String i : p) {
// If permutation is not in newlist
if (!newList.contains(i)) {
newList.add(i);
}
}
// Initialize empty list
List<Integer> permuteList = new ArrayList<>();
// Traverse the list newList[]
for (String i : newList) {
// Convert string to integer
int s = Integer.parseInt(i);
// Append the unique permutation to permuteList
permuteList.add(s);
}
// Print all distinct permutations
for (int i : permuteList) {
System.out.print(i + " ");
}
}
// Function to print all distinct permutations
static void uniquePermutations(int N)
{
// Stores equivalent string representation of N
String num = Integer.toString(N);
List<Character> lis = new ArrayList<>();
for (char c : num.toCharArray()) {
lis.add(c);
}
Collections.sort(lis);
List<String> permute = new ArrayList<>();
do {
char[] charArray = new char[lis.size()];
for (int i = 0; i < lis.size(); i++) {
charArray[i] = lis.get(i);
}
permute.add(new String(charArray));
} while (nextPermutation(lis));
// Print unique permutations
uniquePermutationsUtil(permute);
}
// Function to find the next permutation
static boolean nextPermutation(List<Character> array)
{
int i = array.size() - 1;
while (i > 0 && array.get(i - 1) >= array.get(i)) {
i--;
}
if (i <= 0) {
return false;
}
int j = array.size() - 1;
while (array.get(j) <= array.get(i - 1)) {
j--;
}
// Swap the characters at positions i-1 and j
char temp = array.get(i - 1);
array.set(i - 1, array.get(j));
array.set(j, temp);
// Reverse the suffix starting at position i
j = array.size() - 1;
while (i < j) {
temp = array.get(i);
array.set(i, array.get(j));
array.set(j, temp);
i++;
j--;
}
return true;
}
// Driver Code
public static void main(String[] args)
{
// Given value of N
int N = 7668;
// Function call to find all distinct permutations
// of N
uniquePermutations(N);
}
}
# Python3 program for the above approach
from itertools import permutations
# Utility function to print
# all distinct permutations
def uniquePermutationsUtil(permute):
p = []
# Traverse the list permute[]
for i in permute:
# Convert this permutation to list
permutelist = list(i)
# Append this list to p
p.append(permutelist)
# Stores unique permutations
newlist = []
# Traverse list p[]
for i in p:
# If permutation is
# not in newlist
if i not in newlist:
newlist.append(i)
# Initialize empty list
permutelist = []
# Traverse the list newlist[]
for i in newlist:
# Initialize empty string
s = ""
# Traversing in element list
for j in i:
# Convert each
# element to string
s = s + str(j)
# Convert string to integer
s = int(s)
# Append the unique
# permutation to permutelist
permutelist.append(s)
# Print all distinct permutations
print(*permutelist)
# Function to print all
# distinct permutations
def uniquePermutations(N):
# Stores equivalent string
# representation of N
num = str(N)
# Convert each character to
# integer and store in the list
lis = list(map(int, num))
# Built in method to store all
# permutations of the list
permute = permutations(lis)
# Print unique permutations
uniquePermutationsUtil(permute)
# Driver Code
# Given value of N
N = 7668
# Function call to find all
# distinct permutations of N
uniquePermutations(N)
using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
// Utility function to print all distinct permutations
static void UniquePermutationsUtil(List<string> permute)
{
List<string> p = new List<string>();
// Traverse the list permute[]
foreach (string i in permute)
{
// Convert this permutation to list
p.Add(i);
}
// Stores unique permutations
List<string> newlist = new List<string>();
// Traverse list p[]
foreach (string i in p)
{
// If permutation is not in newlist
if (!newlist.Contains(i))
{
newlist.Add(i);
}
}
// Initialize empty list
List<int> permutelist = new List<int>();
// Traverse the list newlist[]
foreach (string i in newlist)
{
// Convert string to integer
int s = int.Parse(i);
// Append the unique permutation to permutelist
permutelist.Add(s);
}
// Print all distinct permutations
foreach (int i in permutelist)
{
Console.Write(i + " ");
}
}
// Function to print all distinct permutations
static void UniquePermutations(int N)
{
// Stores equivalent string representation of N
string num = N.ToString();
List<char> lis = num.ToList();
List<string> permute = new List<string>();
lis.Sort();
do
{
permute.Add(new string(lis.ToArray()));
} while (NextPermutation(lis));
// Print unique permutations
UniquePermutationsUtil(permute);
}
// Function to find the next permutation
static bool NextPermutation(List<char> array)
{
int i = array.Count - 1;
while (i > 0 && array[i - 1] >= array[i])
{
i--;
}
if (i <= 0)
{
return false;
}
int j = array.Count - 1;
while (array[j] <= array[i - 1])
{
j--;
}
// Swap the characters at positions i-1 and j
char temp = array[i - 1];
array[i - 1] = array[j];
array[j] = temp;
// Reverse the suffix starting at position i
j = array.Count - 1;
while (i < j)
{
temp = array[i];
array[i] = array[j];
array[j] = temp;
i++;
j--;
}
return true;
}
// Driver Code
static void Main()
{
// Given value of N
int N = 7668;
// Function call to find all distinct permutations of N
UniquePermutations(N);
}
}
// JavaScript program for the above approach
// This function generates all the permutations of arr
function permutations(arr) {
var results = [];
var permute = function(arr, memo) {
var curr, memo = memo || [];
for (var i = 0; i < arr.length; i++) {
curr = arr.splice(i, 1);
if (arr.length === 0) {
results.push(memo.concat(curr));
}
permute(arr.slice(), memo.concat(curr));
arr.splice(i, 0, curr[0]);
}
return results;
}
return permute(arr);
}
// Utility function to print all distinct permutations
function uniquePermutationsUtil(permute) {
var p = [];
// Traverse the list permute[]
for (var i of permute) {
// Convert this permutation to array
var permutelist = [...i];
// Append this array to p
p.push(permutelist);
}
// Stores unique permutations
var newlist = [];
// Traverse array p[]
for (var i of p) {
// If permutation is not in newlist
if (!newlist.some(function(v) {
return v.toString() === i.toString();
})) {
newlist.push(i);
}
}
// Initialize empty array
var permutelist = [];
// Traverse the array newlist[]
for (var i of newlist) {
// Initialize empty string
var s = "";
// Traversing in element array
for (var j of i) {
// Append each element to string
s += j.toString();
}
// Convert string to integer
s = parseInt(s);
// Append the unique
// permutation to permutelist
permutelist.push(s);
}
// Print all distinct permutations
console.log(...permutelist);
}
// Function to print all distinct permutations
function uniquePermutations(N) {
// Stores equivalent string
// representation of N
var num = N.toString();
// Convert each character to integer and store in the array
var lis = num.split('').map(Number);
// Built in method to store all permutations of the array
var permute = permutations(lis);
// Print unique permutations
uniquePermutationsUtil(permute);
}
// Driver Code
// Given value of N
var N = 7668;
// Function call to find all distinct permutations of N
uniquePermutations(N);
Output7668 7686 7866 6768 6786 6678 6687 6876 6867 8766 8676 8667
Time Complexity: O(N * N!)
Auxiliary Space: O(N * N!)
Similar Reads
Number of distinct permutation a String can have We are given a string having only lowercase alphabets. The task is to find out total number of distinct permutation can be generated by that string. Examples: Input : aab Output : 3 Different permutations are "aab", "aba" and "baa". Input : ybghjhbuytb Output : 1663200 A simple solution is to find a
6 min read
CSES Solutions - Distinct Numbers You are given a list of N integers arr[], and your task is to calculate the number of distinct values in the list. Examples: Input: N = 5, arr[] = {2, 2, 3, 3, 2}Output: 2Explanation: There are only two distinct elements: 2 and 3 in the array arr[]. Input: N = 6, arr[] = {1, 1, 2, 2, 3, 4}Output: 4E
5 min read
Generate all cyclic permutations of a number Given a number N, our task is to generate all the possible cyclic permutations of the number. A cyclic permutation shifts all the elements of a set by a fixed offset. For a set with elements a_0 , a_1 , ..., a_n , a cyclic permutation of one place to the left would yield a_1 , ..., a_n , a_0 , and a
6 min read
Count the number of special permutations Given two positive integers n and k, the task is to count the number of special permutations. A special permutation P is defined as a permutation of first n natural numbers in which there exists at least (n - k) indices such that Pi = i. Prerequisite: Derangements Examples: Input: n = 4, k = 2 Outpu
15+ min read
K difference permutation Given two integers n and k. Consider first permutation of natural n numbers, P = "1 2 3 ... n", print a permutation "Result" such that abs(Resulti - Pi) = k where Pi denotes the position of i in permutation P. The value of Pi varies from 1 to n. If there are multiple possible results, then print the
8 min read