# Count number of permutation of an Array having no SubArray of size two or more from original Array

• Difficulty Level : Easy
• Last Updated : 08 Mar, 2022

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:
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:

## Python3

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

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``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`

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

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

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

## Javascript

 ``

Output:

`11`

Note: For the above recurrence you can check oeis.org

Time Complexity: O(2^n)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up