Open In App

# 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 = 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 those indexes should be included in the 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] = 1;``    ``for` `(``int` `i = 1; i < N; i++) {``        ``if` `(arr[i] <= arr[i - 1])``            ``prefix[i] = prefix[i - 1] + 1;``        ``else``            ``prefix[i] = 1;``    ``}` `    ``suffix[N - 1] = 1;``    ``for` `(``int` `i = N - 2; i >= 0; i--) {``        ``if` `(arr[i] <= arr[i + 1])``            ``suffix[i] = suffix[i + 1] + 1;``        ``else``            ``suffix[i] = 1;``    ``}` `    ``for` `(``int` `i = 0; i < N; i++) {``        ``if` `(K == 0``            ``|| i - 1 >= 0 && i + 1 < N && prefix[i - 1] >= K``                   ``&& suffix[i + 1] >= 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``] = ``1``;``        ``for` `(``int` `i = ``1``; i < N; i++) {``            ``if` `(arr[i] <= arr[i - ``1``])``                ``prefix[i] = prefix[i - ``1``] + ``1``;``            ``else``                ``prefix[i] = ``1``;``        ``}` `        ``suffix[N - ``1``] = ``1``;``        ``for` `(``int` `i = N - ``2``; i >= ``0``; i--) {``            ``if` `(arr[i] <= arr[i + ``1``])``                ``suffix[i] = suffix[i + ``1``] + ``1``;``            ``else``                ``suffix[i] = ``1``;``        ``}` `        ``for` `(``int` `i = ``0``; i < N; i++) {``            ``if` `(K == ``0``                ``|| i - ``1` `>= ``0` `&& i + ``1` `< N``                       ``&& prefix[i - ``1``] >= K``                       ``&& suffix[i + ``1``] >= 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``] ``=` `1``    ``for` `i ``in` `range``(``1``, N):``        ``if` `(arr[i] <``=` `arr[i ``-` `1``]):``            ``prefix[i] ``=` `prefix[i ``-` `1``] ``+` `1``        ``else``:``            ``prefix[i] ``=` `1` `    ``suffix[N ``-` `1``] ``=` `1``    ``for` `i ``in` `range``(N ``-` `2``, ``1``, ``-``1``):``        ``if` `(arr[i] <``=` `arr[i ``+` `1``]):``            ``suffix[i] ``=` `suffix[i ``+` `1``] ``+` `1``        ``else``:``            ``suffix[i] ``=` `1` `    ``for` `i ``in` `range``(N):``        ``if` `(K ``=``=` `0` `or` `i ``-` `1` `>``=` `0` `and` `i ``+` `1` `< N ``and` `prefix[i ``-` `1``] >``=` `K``                ``and` `suffix[i ``+` `1``] >``=` `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] = 1;``        ``for` `(``int` `i = 1; i < N; i++) {``            ``if` `(arr[i] <= arr[i - 1])``                ``prefix[i] = prefix[i - 1] + 1;``            ``else``                ``prefix[i] = 1;``        ``}` `        ``suffix[N - 1] = 1;``        ``for` `(``int` `i = N - 2; i >= 0; i--) {``            ``if` `(arr[i] <= arr[i + 1])``                ``suffix[i] = suffix[i + 1] + 1;``            ``else``                ``suffix[i] = 1;``        ``}` `        ``for` `(``int` `i = 0; i < N; i++) {``            ``if` `(K == 0``                ``|| i - 1 >= 0 && i + 1 < N``                       ``&& prefix[i - 1] >= K``                       ``&& suffix[i + 1] >= 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.