# Rank of remaining numbers in Array by replacing first and last with max and min alternatively

Given an array **arr[ ]** of size **N**, the task is to find the rank of the remaining element in an array after performing the given operation:

- In each operation choose elements from
**both ends**and delete them and insert the**max of those values**at the position of the left element and move one step towards the center from both ends and keep performing this operation. - In the
**next cycle**keep performing the same operation but instead of max,**insert min**of the elements this time. - Perform this operation in
**alternate cycles**until there is only**one element left**in the array. - The rank is the
**position**of the remaining element**in the original array**when it is**sorted**in increasing order. (The elements with same values are considered only for the sorted order)

**Examples:**

Input:arr ={4, 5, 3, 56, 3, 24, 5, 6, 22, 4, 55, 50, 89}Output:6Explanation:See the diagram given below24 is th 6th smallest element. The elements with same values are considered once.

Input:N = {20, 4, 5, 35, 6, 22, 4, 34}Output:6

**Approach: **The solution is based on two pointer approach. Follow the steps mentioned below:

- Take
**c as 1**which will indicate the number of iterations.- Take 2 pointers, start as zero and end as
**N-1**. - Compare element at index
**s**and**e**. - If
**c is odd**then take the**maximum**of the element**else**take the**minimum**of element and store in an array. - Increment
**s**, decrement**e**and repeat till**s != e**.

- Take 2 pointers, start as zero and end as
- Increment
**c by 1** - Repeat step 2 till the length of arr becomes 1.
- Remove duplicate from
**arr[]**and sort it, now find the rank of the remaining element.

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 rank of number in array` `int` `rankOfNum(vector<` `int` `>& num)` `{` ` ` `// Copying array to S` ` ` `vector<` `int` `> S = num;` ` ` `// c count no of iterations` ` ` `int` `c = 1;` ` ` `while` `(S.size() != 1) {` ` ` `// s is starting index` ` ` `int` `s = 0;` ` ` `// e is ending index` ` ` `int` `e = S.size() - 1;` ` ` `// Empty array to store` ` ` `// result of comparisons.` ` ` `vector<` `int` `> l;` ` ` `// loop till s <= e` ` ` `while` `(s <= e) {` ` ` `// In odd iterations take` ` ` `// maximum of element.` ` ` `if` `(c % 2 == 1)` ` ` `l.push_back(max(S[s], S[e]));` ` ` `// In even Iterations` ` ` `// take minimum of element.` ` ` `else` `{` ` ` `l.push_back(min(S[s], S[e]));` ` ` `}` ` ` `// Increment s by 1` ` ` `// and decrement e by 1` ` ` `s += 1;` ` ` `e -= 1;` ` ` `}` ` ` `// Assigning l to S` ` ` `S = l;` ` ` `// Increment iteration value by 1` ` ` `c += 1;` ` ` `}` ` ` `// Converting list into set and again to list` ` ` `// so that all duplicate will get removed` ` ` `set<` `int` `> setx;` ` ` `for` `(` `auto` `dt : num)` ` ` `setx.insert(dt);` ` ` `// Finding index of remained element` ` ` `int` `p = distance(setx.begin(), setx.find(S[0]));` ` ` `// Returning the rank of element` ` ` `return` `p + 1;` `}` `// Driver code` `int` `main()` `{` ` ` `// Original array` ` ` `vector<` `int` `> arr` ` ` `= { 4, 5, 3, 56, 3, 24, 5, 6, 22, 4, 55, 50, 89 };` ` ` `// Calling function` ` ` `int` `s = rankOfNum(arr);` ` ` `// Print its rank` ` ` `cout << s;` ` ` `return` `0;` `}` `// This code is contributed by rakeshsahni` |

## Java

`// Java code for the above approach` `import` `java.util.*;` `class` `GFG{` `// Function to find rank of number in array` `static` `int` `rankOfNum(Integer[] num)` `{` ` ` `// Copying array to S` ` ` `List<Integer> S = Arrays.asList(num);` ` ` `// c count no of iterations` ` ` `int` `c = ` `1` `;` ` ` `while` `(S.size() != ` `1` `) {` ` ` `// s is starting index` ` ` `int` `s = ` `0` `;` ` ` `// e is ending index` ` ` `int` `e = S.size() - ` `1` `;` ` ` `// Empty array to store` ` ` `// result of comparisons.` ` ` `ArrayList<Integer> l = ` `new` `ArrayList<Integer>();` ` ` `// loop till s <= e` ` ` `while` `(s <= e) {` ` ` `// In odd iterations take` ` ` `// maximum of element.` ` ` `if` `(c % ` `2` `== ` `1` `)` ` ` `l.add(Math.max(S.get(s), S.get(e)));` ` ` `// In even Iterations` ` ` `// take minimum of element.` ` ` `else` `{` ` ` `l.add(Math.min(S.get(s), S.get(e)));` ` ` `}` ` ` `// Increment s by 1` ` ` `// and decrement e by 1` ` ` `s += ` `1` `;` ` ` `e -= ` `1` `;` ` ` `}` ` ` `// Assigning l to S` ` ` `S = l;` ` ` `// Increment iteration value by 1` ` ` `c += ` `1` `;` ` ` `}` ` ` `// Converting list into set and again to list` ` ` `// so that all duplicate will get removed` ` ` `HashSet<Integer> setx = ` `new` `HashSet<Integer>();` ` ` `for` `(` `int` `dt : num)` ` ` `setx.add(dt);` ` ` `// Finding index of remained element` ` ` `List<Integer> l = ` `new` `LinkedList<>(setx);` ` ` `Collections.sort(l);` ` ` `int` `p = l.indexOf(S.get(` `0` `));` ` ` `// Returning the rank of element` ` ` `return` `p + ` `1` `;` `}` `// Driver code` `public` `static` `void` `main(String[] args)` `{` ` ` `// Original array` ` ` `Integer[] arr` ` ` `= { ` `4` `, ` `5` `, ` `3` `, ` `56` `, ` `3` `, ` `24` `, ` `5` `, ` `6` `, ` `22` `, ` `4` `, ` `55` `, ` `50` `, ` `89` `};` ` ` `// Calling function` ` ` `int` `s = rankOfNum(arr);` ` ` `// Print its rank` ` ` `System.out.print(s);` `}` `}` `// This code is contributed by 29AjayKumar` |

## Python3

`# Python code to implement above approach` `# Function to find rank of number in array` `def` `rankOfNum(num):` ` ` `# Copying array to S` ` ` `S ` `=` `num[:]` ` ` `# c count no of iterations` ` ` `c ` `=` `1` ` ` `while` `len` `(S) !` `=` `1` `:` ` ` `# s is starting index` ` ` `s ` `=` `0` ` ` `# e is ending index` ` ` `e ` `=` `len` `(S) ` `-` `1` ` ` `# Empty array to store` ` ` `# result of comparisons.` ` ` `l ` `=` `[]` ` ` `# loop till s <= e` ` ` `while` `s <` `=` `e:` ` ` `# In odd iterations take` ` ` `# maximum of element.` ` ` `if` `c ` `%` `2` `=` `=` `1` `:` ` ` `l.append(` `max` `(S[s], S[e]))` ` ` `# In even Iterations` ` ` `# take minimum of element.` ` ` `else` `:` ` ` `l.append(` `min` `(S[s], S[e]))` ` ` `# Increment s by 1` ` ` `# and decrement e by 1` ` ` `s ` `+` `=` `1` ` ` `e ` `-` `=` `1` ` ` `# Assigning l to S` ` ` `S ` `=` `l` ` ` `# Increment iteration value by 1` ` ` `c ` `+` `=` `1` ` ` `# Converting list into set and again to list` ` ` `# so that all duplicate will get removed` ` ` `setx ` `=` `list` `(` `set` `(num))` ` ` `# Sorting to get rank` ` ` `setx.sort()` ` ` `# Finding index of remained element` ` ` `p ` `=` `setx.index(S[` `0` `])` ` ` `# Returning the rank of element` ` ` `return` `p ` `+` `1` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `# Original array` ` ` `arr ` `=` `[` `4` `, ` `5` `, ` `3` `, ` `56` `, ` `3` `, ` `24` `, ` `5` `, ` `6` `, ` `22` `, ` `4` `, ` `55` `, ` `50` `, ` `89` `]` ` ` `# Calling function` ` ` `s ` `=` `rankOfNum(arr)` ` ` `# Print its rank` ` ` `print` `(` `str` `(s))` |

## C#

`// C# code for the above approach` `using` `System;` `using` `System.Linq;` `using` `System.Collections.Generic;` `class` `GFG {` ` ` `// Function to find rank of number in array` ` ` `static` `int` `rankOfNum(List<` `int` `> num)` ` ` `{` ` ` `// Copying array to S` ` ` `List<` `int` `> S = num;` ` ` `// c count no of iterations` ` ` `int` `c = 1;` ` ` `while` `(S.Count != 1) {` ` ` `// s is starting index` ` ` `int` `s = 0;` ` ` `// e is ending index` ` ` `int` `e = S.Count - 1;` ` ` `// Empty array to store` ` ` `// result of comparisons.` ` ` `List<` `int` `> l = ` `new` `List<` `int` `>();` ` ` `// loop till s <= e` ` ` `while` `(s <= e) {` ` ` `// In odd iterations take` ` ` `// maximum of element.` ` ` `if` `(c % 2 == 1)` ` ` `l.Add(Math.Max(S[s], S[e]));` ` ` `// In even Iterations` ` ` `// take minimum of element.` ` ` `else` `{` ` ` `l.Add(Math.Min(S[s], S[e]));` ` ` `}` ` ` `// Increment s by 1` ` ` `// and decrement e by 1` ` ` `s += 1;` ` ` `e -= 1;` ` ` `}` ` ` `// Assigning l to S` ` ` `S = l;` ` ` `// Increment iteration value by 1` ` ` `c += 1;` ` ` `}` ` ` `// Converting list into set and again to list` ` ` `// so that all duplicate will get removed` ` ` `HashSet<` `int` `> setx = ` `new` `HashSet<` `int` `>();` ` ` `foreach` `(` `var` `dt ` `in` `num) setx.Add(dt);` ` ` `// Finding index of remained element` ` ` `List<` `int` `> setxList = setx.ToList();` ` ` `setxList.Sort();` ` ` `int` `p = setxList.IndexOf(S[0]);` ` ` `// Returning the rank of element` ` ` `return` `p + 1;` ` ` `}` ` ` `// Driver code` ` ` `public` `static` `void` `Main()` ` ` `{` ` ` `// Original array` ` ` `List<` `int` `> arr = ` `new` `List<` `int` `>() {` ` ` `4, 5, 3, 56, 3, 24, 5, 6, 22, 4, 55, 50, 89` ` ` `};` ` ` `// Calling function` ` ` `int` `s = rankOfNum(arr);` ` ` `// Print its rank` ` ` `Console.Write(s);` ` ` `}` `}` `// This code is contributed by ukasp.` |

## Javascript

`<script>` ` ` `// JavaScript code for the above approach` ` ` `// Function to find rank of number in array` ` ` `function` `rankOfNum(num) {` ` ` `// Copying array to S` ` ` `let S = [...num]` ` ` `// c count no of iterations` ` ` `c = 1` ` ` `while` `(S.length != 1) {` ` ` `// s is starting index` ` ` `s = 0` ` ` `// e is ending index` ` ` `e = S.length - 1` ` ` `// Empty array to store` ` ` `// result of comparisons.` ` ` `l = []` ` ` `// loop till s <= e` ` ` `while` `(s <= e) {` ` ` `// In odd iterations take` ` ` `// maximum of element.` ` ` `if` `(c % 2 == 1)` ` ` `l.push(Math.max(S[s], S[e]))` ` ` `// In even Iterations` ` ` `// take minimum of element.` ` ` `else` `{` ` ` `l.push(Math.min(S[s], S[e]))` ` ` `}` ` ` `// Increment s by 1` ` ` `// and decrement e by 1` ` ` `s += 1` ` ` `e -= 1` ` ` `}` ` ` `// Assigning l to S` ` ` `S = [...l]` ` ` `// Increment iteration value by 1` ` ` `c += 1` ` ` `}` ` ` ` ` `// Converting list into set and again to list` ` ` `// so that all duplicate will get removed` ` ` `let setx = ` `new` `Set([...num])` ` ` `// Sorting to get rank` ` ` `t = [...setx].sort(` `function` `(a, b) { ` `return` `a - b })` ` ` `// Finding index of remained element` ` ` `let p = t.indexOf(S[0])` ` ` ` ` `// Returning the rank of element` ` ` `return` `p + 1` ` ` `}` ` ` ` ` `// Original array` ` ` `arr = [4, 5, 3, 56, 3, 24, 5, 6, 22, 4, 55, 50, 89]` ` ` `// Calling function` ` ` `s = rankOfNum(arr)` ` ` `// Print its rank` ` ` `document.write((s))` ` ` `// This code is contributed by Potta Lokesh` ` ` `</script>` |

**Output**

6

* Time Complexity:* O(N)

*O(N)*

**Space Complexity:**