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

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 = 0Output:0 1 2 3 4Explanation:Since K equals 0, every index satisfies the condition.

Input:arr[] = {1, 2, 3, 4, 5, 6}, K = 2Output:-1Explanation: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:

- Form the
**prefix[]**array where**prefix[i]**represents the number of elements before**i**which obeys**non-increasing**order. - Form the
**suffix[]**array where**suffix[i]**represents the number of elements after**i**which obeys**non-decreasing**order. - 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 <bits/stdc++.h>` `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<Integer> findIndices(` `int` `[] arr, ` `int` `K, ` `int` `N)` ` ` `{` ` ` `int` `[] prefix = ` `new` `int` `[N];` ` ` `int` `[] suffix = ` `new` `int` `[N];` ` ` `ArrayList<Integer> ans = ` `new` `ArrayList<Integer>();` ` ` `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<Integer> 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

`<script>` ` ` `// JavaScript code for the above approach` ` ` `// Function to find all the indices` ` ` `const findIndices = (arr, K, N) => {` ` ` `let prefix = ` `new` `Array(N).fill(0);` ` ` `let suffix = ` `new` `Array(N).fill(0);` ` ` `let ans = [];` ` ` `prefix[0] = 0;` ` ` `for` `(let 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` `(let i = N - 2; i >= 0; i--) {` ` ` `if` `(arr[i] <= arr[i + 1])` ` ` `suffix[i] = suffix[i + 1] + 1;` ` ` `else` ` ` `suffix[i] = 0;` ` ` `}` ` ` `for` `(let i = 0; i < N; i++) {` ` ` `if` `(prefix[i] >= K && suffix[i] >= K)` ` ` `ans.push(i);` ` ` `}` ` ` `return` `ans;` ` ` `}` ` ` `// Driver code` ` ` `let arr = [1, 1, 1, 1, 1];` ` ` `let K = 0;` ` ` `let N = arr.length;` ` ` `let ans = findIndices(arr, K, N);` ` ` `for` `(let i = 0; i < ans.length; i++) {` ` ` `document.write(`${ans[i]} `);` ` ` `}` ` ` `if` `(ans.length == 0)` ` ` `cout << ` `"-1"` `;` `// This code is contributed by rakeshsahni` `</script>` |

**Output**

0 1 2 3 4

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