Given an array of **distinct** integer **A**, the task is to count the number of possible permutations of the given array A[] such that the permutations do not contain any subarray of size 2 or more from the original array.

**Examples:**

Input:A = [ 1, 3, 9 ]

Output:3

All the permutation of [ 1, 3, 9 ] are : [ 1, 3, 9 ], [ 1, 9, 3 ], [ 3, 9, 1 ], [ 3, 1, 9 ], [ 9, 1, 3 ], [ 9, 3, 1 ]Here [ 1, 3, 9 ], [ 9, 1, 3 ] are removed as they contain sub-array [ 1, 3 ] from original list

and [ 3, 9, 1 ] removed as it contains sub-array [3, 9] from original list so,

Following are the 3 arrays that satisfy the condition : [1, 9, 3], [3, 1, 9], [9, 3, 1]

Input :A = [1, 3, 9, 12]

Output :11

**Naive Approach: **Iterate through list of all permutations and remove those arrays which contains any sub-array **[ i, i+1 ]** from **A**.

Below is the implementation of the above approach:

`# Python implementation of the approach ` ` ` `# Importing the itertools ` `from` `itertools ` `import` `permutations ` ` ` `# Function that return count of all the permutation ` `# having no sub-array of [ i, i + 1 ] ` `def` `count(arr): ` ` ` `z ` `=` `[] ` ` ` `perm ` `=` `permutations(arr) ` ` ` `for` `i ` `in` `list` `(perm): ` ` ` `z.append(` `list` `(i)) ` ` ` ` ` `q ` `=` `[] ` ` ` `for` `i ` `in` `range` `(` `len` `(arr)` `-` `1` `): ` ` ` `x, y ` `=` `arr[i], arr[i ` `+` `1` `] ` ` ` `for` `j ` `in` `range` `(` `len` `(z)): ` ` ` ` ` `# Finding the indexes where x is present ` ` ` `if` `z[j].index(x)!` `=` `len` `(z[j])` `-` `1` `: ` ` ` ` ` `# If y is present at position of x + 1 ` ` ` `# append into a temp list q ` ` ` `if` `z[j][z[j].index(x)` `+` `1` `]` `=` `=` `y: ` ` ` `q.append(z[j]) ` ` ` ` ` `# Removing all the lists that are present ` ` ` `# in z ( list of all premutations ) ` ` ` `for` `i ` `in` `range` `(` `len` `(q)): ` ` ` `if` `q[i] ` `in` `z: ` ` ` `z.remove(q[i]) ` ` ` `return` `len` `(z) ` ` ` `# Driver Code ` `A ` `=` `[` `1` `, ` `3` `, ` `9` `] ` `print` `(count(A)) ` |

*chevron_right*

*filter_none*

**Output:**

3

**Efficient Solution :** After making the solution for smaller size of array, we can observe a pattern:

The following pattern generates a recurrence:

Suppose the length of array **A** is n, then:

count(0) = 1 count(1) = 1 count(n) = n * count(n-1) + (n-1) * count(n-2)

Below is the implementation of the approach:

## C++

`// C++ implementation of the approach ` `#include<bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Recursive function that returns ` `// the count of permutation-based ` `// on the length of the array. ` `int` `count(` `int` `n) ` `{ ` ` ` `if` `(n == 0) ` ` ` `return` `1; ` ` ` `if` `(n == 1) ` ` ` `return` `1; ` ` ` `else` ` ` `return` `(n * count(n - 1)) + ` ` ` `((n - 1) * count(n - 2)); ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `int` `A[] = {1, 2, 3, 9}; ` ` ` ` ` `// length of array ` ` ` `int` `n = 4; ` ` ` ` ` `// Output required answer ` ` ` `cout << count(n - 1); ` ` ` ` ` `return` `0; ` `} ` ` ` `// This code is contributed by Sanjit Prasad ` |

*chevron_right*

*filter_none*

## Java

`// Java implementation of the approach ` `import` `java.util.*; ` ` ` `class` `GFG ` `{ ` ` ` `// Recursive function that returns ` `// the count of permutation-based ` `// on the length of the array. ` `static` `int` `count(` `int` `n) ` `{ ` ` ` `if` `(n == ` `0` `) ` ` ` `return` `1` `; ` ` ` `if` `(n == ` `1` `) ` ` ` `return` `1` `; ` ` ` `else` ` ` `return` `(n * count(n - ` `1` `)) + ` ` ` `((n - ` `1` `) * count(n - ` `2` `)); ` `} ` ` ` `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` ` ` `int` `A[] = {` `1` `, ` `2` `, ` `3` `, ` `9` `}; ` ` ` ` ` `// length of array ` ` ` `int` `n = ` `4` `; ` ` ` ` ` `// Output required answer ` ` ` `System.out.println(count(n - ` `1` `)); ` `} ` `} ` ` ` `// This code is contributed by PrinciRaj1992 ` |

*chevron_right*

*filter_none*

## Python3

`# Python implementation of the approach ` ` ` `# Recursive function that returns ` `# the count of permutation-based ` `# on the length of the array. ` ` ` `def` `count(n): ` ` ` `if` `n ` `=` `=` `0` `: ` ` ` `return` `1` ` ` `if` `n ` `=` `=` `1` `: ` ` ` `return` `1` ` ` `else` `: ` ` ` `return` `(n ` `*` `count(n` `-` `1` `)) ` `+` `((n` `-` `1` `) ` `*` `count(n` `-` `2` `)) ` ` ` `# Driver Code ` `A ` `=` `[` `1` `, ` `2` `, ` `3` `, ` `9` `] ` `print` `(count(` `len` `(A)` `-` `1` `)) ` |

*chevron_right*

*filter_none*

## C#

`// C# implementation of the above approach ` `using` `System; ` ` ` `class` `GFG ` `{ ` ` ` `// Recursive function that returns ` `// the count of permutation-based ` `// on the length of the array. ` `static` `int` `count(` `int` `n) ` `{ ` ` ` `if` `(n == 0) ` ` ` `return` `1; ` ` ` `if` `(n == 1) ` ` ` `return` `1; ` ` ` `else` ` ` `return` `(n * count(n - 1)) + ` ` ` `((n - 1) * count(n - 2)); ` `} ` ` ` `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` ` ` `int` `[]A = {1, 2, 3, 9}; ` ` ` ` ` `// length of array ` ` ` `int` `n = 4; ` ` ` ` ` `// Output required answer ` ` ` `Console.WriteLine(count(n - 1)); ` `} ` `} ` ` ` `// This code is contributed by PrinciRaj1992 ` |

*chevron_right*

*filter_none*

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.