# Generate all possible permutations of a Number divisible by N

Given a numerical string S, the task is to print all the permutations of the string which are divisible by N.

Examples:

Input: N = 5, S = “125”
Output: 125 215
Explanation:
All possible permutations are S are {125, 152, 215, 251, 521, 512}.
Out of these 6 permutations, only 2 {125, 215} are divisible by N (= 5).

Input: N = 7, S = “4321”
Output: 4312 4123 3241

Approach: The idea is to generate all possible permutations and for each permutation, check if it is divisible by N or not. For each permutation found to be divisible by N, print them.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement` `// the above approach` `#include ` `using` `namespace` `std;`   `// Function to Swap two` `// characters` `void` `swap_(``char``& a, ``char``& b)` `{` `    ``char` `temp;` `    ``temp = a;` `    ``a = b;` `    ``b = temp;` `}`   `// Function to generate all permutations` `// and print the ones that are` `// divisible by the N` `void` `permute(``char``* str, ``int` `l, ``int` `r, ``int` `n)` `{` `    ``int` `i;`   `    ``if` `(l == r) {`   `        ``// Convert string to integer` `        ``int` `j = ``atoi``(str);`   `        ``// Check for divisibility` `        ``// and print it` `        ``if` `(j % n == 0)` `            ``cout << str << endl;`   `        ``return``;` `    ``}`   `    ``// Print all the permutations` `    ``for` `(i = l; i < r; i++) {`   `        ``// Swap characters` `        ``swap_(str[l], str[i]);`   `        ``// Permute remaining` `        ``// characters` `        ``permute(str, l + 1, r, n);`   `        ``// Revoke the swaps` `        ``swap_(str[l], str[i]);` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``char` `str = ``"125"``;` `    ``int` `n = 5;` `    ``int` `len = ``strlen``(str);`   `    ``if` `(len > 0)` `        ``permute(str, 0, len, n);`   `    ``return` `0;` `}`

## Java

 `// Java program to implement` `// the above approach` `class` `GFG{`   `// Function to Swap two` `// characters` `static` `void` `swap_(``char` `[]a, ``int` `l, ``int` `i)` `{` `    ``char` `temp;` `    ``temp = a[l];` `    ``a[l] = a[i];` `    ``a[i] = temp;` `}`   `// Function to generate all permutations` `// and print the ones that are` `// divisible by the N` `static` `void` `permute(``char``[] str, ``int` `l, ` `                         ``int` `r, ``int` `n)` `{` `    ``int` `i;`   `    ``if` `(l == r)` `    ``{` `        `  `        ``// Convert String to integer` `        ``int` `j = Integer.valueOf(String.valueOf(str));`   `        ``// Check for divisibility` `        ``// and print it` `        ``if` `(j % n == ``0``)` `            ``System.out.print(String.valueOf(str) + ``"\n"``);`   `        ``return``;` `    ``}`   `    ``// Print all the permutations` `    ``for``(i = l; i < r; i++) ` `    ``{` `        `  `        ``// Swap characters` `        ``swap_(str, l, i);`   `        ``// Permute remaining` `        ``// characters` `        ``permute(str, l + ``1``, r, n);`   `        ``// Revoke the swaps` `        ``swap_(str, l, i);` `    ``}` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``String str = ``"125"``;` `    ``int` `n = ``5``;` `    ``int` `len = str.length();`   `    ``if` `(len > ``0``)` `        ``permute(str.toCharArray(), ``0``, len, n);` `}` `}`   `// This code is contributed by amal kumar choubey `

## Python3

 `# Python3 Program to implement` `# the above approach`   `# Function to generate all ` `# permutations and print ` `# the ones that are` `# divisible by the N` `def` `permute(st, l, r, n):`   `    ``if` `(l ``=``=` `r):`   `        ``# Convert string ` `        ``# to integer` `        ``p ``=` `''.join(st)` `        ``j ``=` `int``(p)`   `        ``# Check for divisibility` `        ``# and print it` `        ``if` `(j ``%` `n ``=``=` `0``):` `            ``print` `(p)`   `        ``return`   `    ``# Print all the ` `    ``# permutations` `    ``for` `i ``in` `range``(l, r):`   `        ``# Swap characters` `        ``st[l], st[i] ``=` `st[i], st[l]`   `        ``# Permute remaining` `        ``# characters` `        ``permute(st, l ``+` `1``, r, n)`   `        ``# Revoke the swaps` `        ``st[l], st[i] ``=` `st[i] ,st[l]`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``st ``=` `"125"` `    ``n ``=` `5` `    ``length ``=` `len``(st)`   `    ``if` `(length > ``0``):` `      ``p ``=` `list``(st)` `      ``permute(p, ``0``, length, n);`   `# This code is contributed by rutvik_56`

## C#

 `// C# program to implement` `// the above approach` `using` `System;`   `class` `GFG{` ` `  `// Function to Swap two` `// characters` `static` `void` `swap_(``char` `[]a, ``int` `l,` `                            ``int` `i)` `{` `    ``char` `temp;` `    ``temp = a[l];` `    ``a[l] = a[i];` `    ``a[i] = temp;` `}` ` `  `// Function to generate all permutations` `// and print the ones that are` `// divisible by the N` `static` `void` `permute(``char``[] str, ``int` `l, ` `                         ``int` `r, ``int` `n)` `{` `    ``int` `i;` ` `  `    ``if` `(l == r)` `    ``{` `        `  `        ``// Convert String to integer` `        ``int` `j = Int32.Parse(``new` `string``(str));` ` `  `        ``// Check for divisibility` `        ``// and print it` `        ``if` `(j % n == 0)` `            ``Console.Write(``new` `string``(str) + ``"\n"``);` ` `  `        ``return``;` `    ``}` ` `  `    ``// Print all the permutations` `    ``for``(i = l; i < r; i++) ` `    ``{` `        `  `        ``// Swap characters` `        ``swap_(str, l, i);` ` `  `        ``// Permute remaining` `        ``// characters` `        ``permute(str, l + 1, r, n);` ` `  `        ``// Revoke the swaps` `        ``swap_(str, l, i);` `    ``}` `}` ` `  `// Driver Code` `public` `static` `void` `Main(``string``[] args)` `{` `    ``string` `str = ``"125"``;` `    ``int` `n = 5;` `    ``int` `len = str.Length;` ` `  `    ``if` `(len > 0)` `        ``permute(str.ToCharArray(), 0, len, n);` `}` `}`   `// This code is contributed by rutvik_56`

Output:

```125
215

```

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

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.