Open In App
Related Articles

Print all the permutation of length L using the elements of an array | Iterative

Improve Article
Improve
Save Article
Save
Like Article
Like

Given an array of unique elements, we have to find all the permutations of length L using the elements of the array. Repetition of elements is allowed.
Examples: 

Input: arr = { 1, 2 }, L=3 
Output: 
111 
211 
121 
221 
112 
212 
122 
222
Input: arr = { 1, 2, 3 }, L=2 
Output: 
11 
21 
31 
12 
22 
32 
13 
23 
33 
 

Approach: 

  • To form a sequence of length L with N number of elements, it is known that the i-th element of the sequence can be filled in N ways. So there will be N^{L}   sequences
  • We will run a loop from 0 to (N^{L} - 1)   , for every i we will convert i from base 10 to base N. The digits of the converted number will represent the indices of the array
  • We can print all the N^{L}   sequences in this way.

Below is the implementation of the approach: 

C++




// C++ implementation
#include <bits/stdc++.h>
using namespace std;
 
// Convert the number to Lth
// base and print the sequence
void convert_To_Len_th_base(int n,
                            int arr[],
                            int len,
                            int L)
{
    // Sequence is of length L
    for (int i = 0; i < L; i++) {
        // Print the ith element
        // of sequence
        cout << arr[n % len];
        n /= len;
    }
    cout << endl;
}
 
// Print all the permuataions
void print(int arr[],
           int len,
           int L)
{
    // There can be (len)^l
    // permutations
    for (int i = 0; i < (int)pow(len, L); i++) {
        // Convert i to len th base
        convert_To_Len_th_base(i, arr, len, L);
    }
}
 
// Driver code
int main()
{
    int arr[] = { 1, 2, 3 };
    int len = sizeof(arr) / sizeof(arr[0]);
    int L = 2;
 
    // function call
    print(arr, len, L);
 
    return 0;
}


Java




// Java implementation for above approach
import java.io.*;
 
class GFG
{
     
// Convert the number to Lth
// base and print the sequence
static void convert_To_Len_th_base(int n, int arr[],
                                   int len, int L)
{
    // Sequence is of length L
    for (int i = 0; i < L; i++)
    {
        // Print the ith element
        // of sequence
        System.out.print(arr[n % len]);
        n /= len;
    }
    System.out.println();
}
 
// Print all the permuataions
static void print(int arr[], int len, int L)
{
    // There can be (len)^l
    // permutations
    for (int i = 0;
             i < (int)Math.pow(len, L); i++)
    {
        // Convert i to len th base
        convert_To_Len_th_base(i, arr, len, L);
    }
}
 
// Driver code
public static void main (String[] args)
{
    int arr[] = { 1, 2, 3 };
    int len = arr.length;
    int L = 2;
     
    // function call
    print(arr, len, L);
}
}
 
// This code is contributed by ajit.


Python3




# Python3 implementation for the above approach
 
# Convert the number to Lth
# base and print the sequence
def convert_To_Len_th_base(n, arr, Len, L):
     
    # Sequence is of Length L
    for i in range(L):
         
        # Print the ith element
        # of sequence
        print(arr[n % Len], end = "")
        n //= Len
    print()
 
# Print all the permuataions
def printf(arr, Len, L):
     
    # There can be (Len)^l permutations
    for i in range(pow(Len, L)):
         
        # Convert i to Len th base
        convert_To_Len_th_base(i, arr, Len, L)
 
# Driver code
arr = [1, 2, 3]
Len = len(arr)
L = 2
 
# function call
printf(arr, Len, L)
 
# This code is contributed by Mohit Kumar


C#




// C# implementation for above approach
using System;
 
class GFG
{
     
// Convert the number to Lth
// base and print the sequence
static void convert_To_Len_th_base(int n, int []arr,
                                   int len, int L)
{
    // Sequence is of length L
    for (int i = 0; i < L; i++)
    {
        // Print the ith element
        // of sequence
        Console.Write(arr[n % len]);
        n /= len;
    }
    Console.WriteLine();
}
 
// Print all the permuataions
static void print(int []arr, int len, int L)
{
    // There can be (len)^l
    // permutations
    for (int i = 0;
            i < (int)Math.Pow(len, L); i++)
    {
        // Convert i to len th base
        convert_To_Len_th_base(i, arr, len, L);
    }
}
 
// Driver code
public static void Main (String[] args)
{
    int []arr = { 1, 2, 3 };
    int len = arr.Length;
    int L = 2;
     
    // function call
    print(arr, len, L);
}
}
 
// This code is contributed by Rajput-Ji


Javascript




<script>
// Javascript implementation
 
// Convert the number to Lth
// base and print the sequence
function convert_To_Len_th_base( n, arr, len, L)
{
    // Sequence is of length L
    for ( i = 0; i < L; i++) {
        // Print the ith element
        // of sequence
        document.write(parseInt(arr[n % len]));
        n = parseInt(n / len);
    }
   document.write("<br>");
}
 
// Print all the permuataions
function print( arr, len, L)
{
    // There can be (len)^l
    // permutations
    for (var i = 0; i < parseInt(Math.pow(len, L)); i++) {
        // Convert i to len th base
        convert_To_Len_th_base(i, arr, len, L);
    }
}
 
var arr = [ 1, 2, 3 ];
var len = arr.length;
var L = 2;
 
// function call
print(arr, len, L);
 
//This code is contributed by SoumikModnal
</script>


Output: 

11
21
31
12
22
32
13
23
33

 

Time Complexity: O(L*lenL), as we are using a loop to traverse pow(len,L) times and in each traversal, we are calling the function convert_To_Len_th_base which will cost O(L). Where L is the number of elements in the array.
Auxiliary Space: O(1), as we are not using any extra space.


Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Last Updated : 22 Jun, 2022
Like Article
Save Article
Similar Reads
Related Tutorials