Open In App

Distinct permutations of a number

Improve
Improve
Like Article
Like
Save
Share
Report

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


Java




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




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


C#




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




// 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);


Output

7668 7686 7866 6768 6786 6678 6687 6876 6867 8766 8676 8667

Time Complexity: O(N * N!)
Auxiliary Space: O(N * N!)



Last Updated : 07 Dec, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads