# Find indices having at least K non-increasing elements before and K non-decreasing elements after them

• Last Updated : 12 Jul, 2022

Given an array arr[] of size N and an integer K, the task is to find all the indices in the given array having at least K non-increasing elements before and K non-decreasing elements after them.

Examples:

Input: arr[] = {1, 1, 1, 1, 1}, K = 0
Output: 0 1 2 3 4
Explanation: Since K equals 0, every index satisfies the condition.

Input: arr[] = {1, 2, 3, 4, 5, 6}, K = 2
Output: -1
Explanation: No index has 2 non-increasing before it and 2 non-decreasing elements after it.

Approach: The solution can be found by using the concept of prefix and suffix array. Follow the steps mentioned below:

1. Form the prefix[] array where prefix[i] represents the number of elements before i which obeys non-increasing order.
2. Form the suffix[] array where suffix[i] represents the number of elements after i which obeys non-decreasing order.
3. Now only that indexes should be included in answer for which, both prefix[i] and suffix[i] are greater than or equal to K.

Below is the implementation of the above approach.

## C++

 `// C++ code for the above approach` `#include ` `using` `namespace` `std;`   `// Function to find all the indices` `vector<``int``> findIndices(``int` `arr[], ``int` `K,` `                        ``int` `N)` `{` `    ``vector<``int``> prefix(N), suffix(N);` `    ``vector<``int``> ans;`   `    ``prefix[0] = 0;` `    ``for` `(``int` `i = 1; i < N; i++) {` `        ``if` `(arr[i] <= arr[i - 1])` `            ``prefix[i] = prefix[i - 1] + 1;` `        ``else` `            ``prefix[i] = 0;` `    ``}`   `    ``suffix[N - 1] = 0;` `    ``for` `(``int` `i = N - 2; i >= 0; i--) {` `        ``if` `(arr[i] <= arr[i + 1])` `            ``suffix[i] = suffix[i + 1] + 1;` `        ``else` `            ``suffix[i] = 0;` `    ``}`   `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``if` `(prefix[i] >= K && suffix[i] >= K)` `            ``ans.push_back(i);` `    ``}`   `    ``return` `ans;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 1, 1, 1, 1, 1 };` `    ``int` `K = 0;` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``vector<``int``> ans = findIndices(arr, K, N);` `    ``for` `(``int` `i = 0; i < ans.size(); i++) {` `        ``cout << ans[i] << ``" "``;` `    ``}` `    ``if` `(ans.size() == 0)` `        ``cout << ``"-1"``;` `    ``return` `0;` `}`

## Java

 `// Java code for the above approach` `import` `java.util.ArrayList;` `class` `GFG {`   `  ``// Function to find all the indices` `  ``static` `ArrayList findIndices(``int``[] arr, ``int` `K, ``int` `N)` `  ``{` `    ``int``[] prefix = ``new` `int``[N];`   `    ``int``[] suffix = ``new` `int``[N];` `    ``ArrayList ans = ``new` `ArrayList();`   `    ``prefix[``0``] = ``0``;` `    ``for` `(``int` `i = ``1``; i < N; i++) {` `      ``if` `(arr[i] <= arr[i - ``1``])` `        ``prefix[i] = prefix[i - ``1``] + ``1``;` `      ``else` `        ``prefix[i] = ``0``;` `    ``}`   `    ``suffix[N - ``1``] = ``0``;` `    ``for` `(``int` `i = N - ``2``; i >= ``0``; i--) {` `      ``if` `(arr[i] <= arr[i + ``1``])` `        ``suffix[i] = suffix[i + ``1``] + ``1``;` `      ``else` `        ``suffix[i] = ``0``;` `    ``}`   `    ``for` `(``int` `i = ``0``; i < N; i++) {` `      ``if` `(prefix[i] >= K && suffix[i] >= K)` `        ``ans.add(i);` `    ``}`   `    ``return` `ans;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main(String args[])` `  ``{` `    ``int``[] arr = { ``1``, ``1``, ``1``, ``1``, ``1` `};` `    ``int` `K = ``0``;` `    ``int` `N = arr.length;` `    ``ArrayList ans = findIndices(arr, K, N);` `    ``for` `(``int` `i = ``0``; i < ans.size(); i++) {` `      ``System.out.print(ans.get(i) + ``" "``);` `    ``}` `    ``if` `(ans.size() == ``0``)` `      ``System.out.println(``"-1"``);` `  ``}` `}`   `// This code is contributed by gfgking`

## Python3

 `# Python code for the above approach`   `# Function to find all the indices` `def` `findIndices (arr, K, N):` `    ``prefix ``=` `[``0``] ``*` `N` `    ``suffix ``=` `[``0``] ``*` `N` `    ``ans ``=` `[];`   `    ``prefix[``0``] ``=` `0``;` `    ``for` `i ``in` `range``(``1``, N):` `        ``if` `(arr[i] <``=` `arr[i ``-` `1``]):` `            ``prefix[i] ``=` `prefix[i ``-` `1``] ``+` `1``;` `        ``else``:` `            ``prefix[i] ``=` `0``;`     `    ``suffix[N ``-` `1``] ``=` `0``;` `    ``for` `i ``in` `range``(N ``-` `2``, ``1``, ``-``1``):` `        ``if` `(arr[i] <``=` `arr[i ``+` `1``]):` `            ``suffix[i] ``=` `suffix[i ``+` `1``] ``+` `1``;` `        ``else``:` `            ``suffix[i] ``=` `0``;`     `    ``for` `i ``in` `range``(N):` `        ``if` `(prefix[i] >``=` `K ``and` `suffix[i] >``=` `K):` `            ``ans.append(i);`   `    ``return` `ans;`   `# Driver code` `arr ``=` `[``1``, ``1``, ``1``, ``1``, ``1``];` `K ``=` `0``;` `N ``=` `len``(arr)` `ans ``=` `findIndices(arr, K, N);` `for` `i ``in` `range``(``len``(ans)):` `    ``print``(ans[i], end``=``" "``);` `if` `(``len``(ans) ``=``=` `0``):` `    ``print``(``"-1"``);`   `# This code is contributed by Saurabh Jaiswal`

## C#

 `// C# code for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG {`   `  ``// Function to find all the indices` `  ``static` `List<``int``> findIndices(``int``[] arr, ``int` `K, ``int` `N)` `  ``{` `    ``int``[] prefix = ``new` `int``[N];`   `    ``int``[] suffix = ``new` `int``[N];` `    ``List<``int``> ans = ``new` `List<``int``>();`   `    ``prefix[0] = 0;` `    ``for` `(``int` `i = 1; i < N; i++) {` `      ``if` `(arr[i] <= arr[i - 1])` `        ``prefix[i] = prefix[i - 1] + 1;` `      ``else` `        ``prefix[i] = 0;` `    ``}`   `    ``suffix[N - 1] = 0;` `    ``for` `(``int` `i = N - 2; i >= 0; i--) {` `      ``if` `(arr[i] <= arr[i + 1])` `        ``suffix[i] = suffix[i + 1] + 1;` `      ``else` `        ``suffix[i] = 0;` `    ``}`   `    ``for` `(``int` `i = 0; i < N; i++) {` `      ``if` `(prefix[i] >= K && suffix[i] >= K)` `        ``ans.Add(i);` `    ``}`   `    ``return` `ans;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `Main()` `  ``{` `    ``int``[] arr = { 1, 1, 1, 1, 1 };` `    ``int` `K = 0;` `    ``int` `N = arr.Length;` `    ``List<``int``> ans = findIndices(arr, K, N);` `    ``for` `(``int` `i = 0; i < ans.Count; i++) {` `      ``Console.Write(ans[i] + ``" "``);` `    ``}` `    ``if` `(ans.Count == 0)` `      ``Console.Write(``"-1"``);` `  ``}` `}`   `// This code is contributed by ukasp`

## Javascript

 ``

Output

`0 1 2 3 4 `

Time Complexity: O(N)
Auxiliary Space: O(N), since N extra space has been taken.

My Personal Notes arrow_drop_up
Recommended Articles
Page :