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

Given an array of unique elements, we have to find all the permutation 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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 sequences
• We will run a loop from 0 to , 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 sequences by this way.

Below is the implementation of the approach:

## C++

 `// C++ implementation ` `#include ` `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); ` `    ``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 `

Output:

```11
21
31
12
22
32
13
23
33
```

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.