# Count of subarrays of size K which is a permutation of numbers from 1 to K

Given an array arr of distinct integers, the task is to find count of sub-arrays of size i having all elements from 1 to i, in other words the sub-array is any permutation of elements from 1 to i, with 1 < = i <= N.
Examples:

Input: arr[] = {2, 3, 1, 5, 4}
Output:
Explanation:
we have {1}, {2, 3, 1} and {2, 3, 1, 5, 4} subarray for i=1, i=3, i=5 respectively.
Permutation of size 4 and size 2 can’t be made because 5 and 3 are in the way respectively.

Input: arr[] = {1, 3, 5, 4, 2}
Output:
Explanation:
we have {1} and {1, 3, 5, 4, 2} subarray for i=1 and i=5 respectively.

A Naive approach is to start from each index and try to find subarray of every size(i) and check whether all elements from 1 to i are present.

Time complexity: O(N2)

An Efficient approach can be given by checking if it is possible to create a subarray of size i for every value of i from 1 to N.
As we know every subarray of size K must be a permutation of all elements from 1 to K, knowing that we can look at the index of the numbers from 1 to N in order and calculate the index of the minimum and maximum value at every step.

• If maximum_ind – minimum_ind + 1 = K, then we have a permutation of size K, else not.
• Update the value of minimum_ind and maximum_ind at every step.

Time complexity: O(n)
Illustration:

Given Arr = {2, 3, 1, 5, 4}, let’s start with min_ind = INF and max_ind = -1

1. index of 1 is 2, so min_ind = min(min_ind, 2) = 2 and max_ind = max(max_ind, 2) = 2,
2-2+1 = 1 so we have a permutation of size 1
2. index of 2 is 0, so min_ind = min(min_ind, 0) = 0 and max_ind = max(max_ind, 0) = 2,
2-0+1 = 3 so we don’t have a permutation of size 2
3. index of 3 is 1, so min_ind = min(min_ind, 1) = 0 and max_ind = max(max_ind, 1) = 2,
2-0+1 = 3 so we have a permutation of size 3
4. index of 4 is 4, so min_ind = min(min_ind, 4) = 0 and max_ind = max(max_ind, 4) = 4,
4-0+1 = 5 so we don’t have a permutation of size 4
5. index of 5 is 3, so min_ind = min(min_ind, 3) = 0 and max_ind = max(max_ind, 4) = 4,
4-0+1 = 5 so we have a permutation of size 5

Below is implementation of the above approach:

## C++

 `// C++ program to implement ` `// the above approach ` ` `  `#include ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `int` `find_permutations(vector<``int``>& arr) ` `{ ` `    ``int` `cnt = 0; ` `    ``int` `max_ind = -1, min_ind = 10000000; ` `    ``int` `n = arr.size(); ` `    ``unordered_map<``int``, ``int``> index_of; ` ` `  `    ``// Save index of numbers of the array ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``index_of[arr[i]] = i + 1; ` `    ``} ` ` `  `    ``for` `(``int` `i = 1; i <= n; i++) { ` ` `  `        ``// Update min and max index ` `        ``// with the current index ` `        ``// and check if it's a valid permutation ` `        ``max_ind = max(max_ind, index_of[i]); ` `        ``min_ind = min(min_ind, index_of[i]); ` `        ``if` `(max_ind - min_ind + 1 == i) ` `            ``cnt++; ` `    ``} ` ` `  `    ``return` `cnt; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``vector<``int``> nums; ` `    ``nums.push_back(2); ` `    ``nums.push_back(3); ` `    ``nums.push_back(1); ` `    ``nums.push_back(5); ` `    ``nums.push_back(4); ` ` `  `    ``cout << find_permutations(nums); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to implement  ` `// the above approach  ` `import` `java.util.*; ` ` `  `class` `GFG{ ` `     `  `public` `static` `int` `find_permutations( ` `    ``Vector arr)  ` `{  ` `    ``int` `cnt = ``0``;  ` `    ``int` `max_ind = -``1``, min_ind = ``10000000``;  ` `    ``int` `n = arr.size();  ` `     `  `    ``HashMap index_of = ``new` `HashMap<>();  ` `             `  `    ``// Save index of numbers of the array  ` `    ``for``(``int` `i = ``0``; i < n; i++)  ` `    ``{  ` `        ``index_of.put(arr.get(i), i + ``1``); ` `    ``}  ` ` `  `    ``for``(``int` `i = ``1``; i <= n; i++)  ` `    ``{  ` `         `  `        ``// Update min and max index with  ` `        ``// the current index and check  ` `        ``// if it's a valid permutation  ` `        ``max_ind = Math.max(max_ind, index_of.get(i));  ` `        ``min_ind = Math.min(min_ind, index_of.get(i));  ` `         `  `        ``if` `(max_ind - min_ind + ``1` `== i)  ` `            ``cnt++;  ` `    ``}  ` `    ``return` `cnt;  ` `}  ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``Vector nums = ``new` `Vector();  ` `    ``nums.add(``2``);  ` `    ``nums.add(``3``);  ` `    ``nums.add(``1``);  ` `    ``nums.add(``5``);  ` `    ``nums.add(``4``);  ` `     `  `    ``System.out.print(find_permutations(nums)); ` `} ` `} ` ` `  `// This code is contributed by divyeshrabadiya07 `

## Python3

 `# Python3 program to implement ` `# the above approach ` `def` `find_permutations(arr): ` `     `  `    ``cnt ``=` `0` `    ``max_ind ``=` `-``1` `    ``min_ind ``=` `10000000``; ` `     `  `    ``n ``=` `len``(arr) ` `    ``index_of ``=` `{} ` ` `  `    ``# Save index of numbers of the array ` `    ``for` `i ``in` `range``(n): ` `        ``index_of[arr[i]] ``=` `i ``+` `1` ` `  `    ``for` `i ``in` `range``(``1``, n ``+` `1``): ` ` `  `        ``# Update min and max index with the ` `        ``# current index and check if it's a ` `        ``# valid permutation ` `        ``max_ind ``=` `max``(max_ind, index_of[i]) ` `        ``min_ind ``=` `min``(min_ind, index_of[i]) ` `         `  `        ``if` `(max_ind ``-` `min_ind ``+` `1` `=``=` `i): ` `            ``cnt ``+``=` `1` `             `  `    ``return` `cnt ` ` `  `# Driver code ` `if` `__name__ ``=``=` `"__main__"``: ` ` `  `    ``nums ``=` `[] ` `    ``nums.append(``2``) ` `    ``nums.append(``3``) ` `    ``nums.append(``1``) ` `    ``nums.append(``5``) ` `    ``nums.append(``4``) ` ` `  `    ``print``(find_permutations(nums)) ` ` `  `# This code is contributed by chitranayal `

## C#

 `// C# program to implement ` `// the above approach ` `using` `System;  ` `using` `System.Collections;  ` `using` `System.Collections.Generic;  ` ` `  `class` `GFG{ ` `     `  `static` `int` `find_permutations(ArrayList arr) ` `{ ` `    ``int` `cnt = 0; ` `    ``int` `max_ind = -1, min_ind = 10000000; ` `    ``int` `n = arr.Count; ` `     `  `    ``Dictionary<``int``,  ` `               ``int``> index_of = ``new` `Dictionary<``int``, ` `                                              ``int``>();  ` `             `  `    ``// Save index of numbers of the array ` `    ``for``(``int` `i = 0; i < n; i++)  ` `    ``{ ` `        ``index_of[(``int``)arr[i]] = i + 1; ` `    ``} ` ` `  `    ``for``(``int` `i = 1; i <= n; i++) ` `    ``{ ` `         `  `        ``// Update min and max index with  ` `        ``// the current index and check  ` `        ``// if it's a valid permutation ` `        ``max_ind = Math.Max(max_ind, index_of[i]); ` `        ``min_ind = Math.Min(min_ind, index_of[i]); ` `         `  `        ``if` `(max_ind - min_ind + 1 == i) ` `            ``cnt++; ` `    ``} ` `    ``return` `cnt; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(``string``[] args) ` `{ ` `    ``ArrayList nums = ``new` `ArrayList();  ` ` `  `    ``nums.Add(2); ` `    ``nums.Add(3); ` `    ``nums.Add(1); ` `    ``nums.Add(5); ` `    ``nums.Add(4); ` ` `  `    ``Console.Write(find_permutations(nums)); ` `} ` `} ` ` `  `// This code is contributed by rutvik_56 `

Output:

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