GeeksforGeeks App
Open App
Browser
Continue

# Find element at given index after given range reversals

An array consisting of N elements is given. There are several reversals we do in unique ranges[L..R]. The task is to print the element at given index.

Examples:

```Input :
arr[] : 10 20 30 40 50
ranges[] = {{1, 4}, {0, 2}}
Query Index = 1
Output : 50
Explanation :
Reverse range[1..4] : 10 50 40 30 20
Reverse range[0..2] : 40 50 10 30 20
So we have 50 at index 1```

The Brute Force approach would be to actually reverse a range of elements and answer the queries afterward.

Efficient Method: If we observe, the reversal of range[L..R] will result as follows :
The index will become right + left – index
By doing this, we can compute the index easily.

Implementation:

## C++

 `// Program to find index of an element after``// given range reversals.``#include ``using` `namespace` `std;` `// Function to compute the element at query index``int` `answer(``int` `arr[], ``int` `ranges[][2], ``int` `reversals,``           ``int` `index)``{``    ``for` `(``int` `i = reversals - 1; i >= 0; i--) {``        ``// Range[left...right]``        ``int` `left = ranges[i][0], right = ranges[i][1];` `        ``// If doesn't satisfy, reversal won't``        ``// have any effect``        ``if` `(left <= index && right >= index)``            ``index = right + left - index;``    ``}` `    ``// Returning element at modified index``    ``return` `arr[index];``}` `// Driver``int` `main()``{``    ``int` `arr[] = { 10, 20, 30, 40, 50 };` `    ``// reversals``    ``int` `reversals = 2;``    ``int` `ranges[reversals][2] = { { 1, 4 }, { 0, 2 } };` `    ``int` `index = 1;``    ``cout << answer(arr, ranges, reversals, index);` `    ``return` `0;``}`

## Java

 `// Program to find index of an element``// after given range reversals.``import` `java.util.Arrays;` `class` `GFG {``    ``// Function to compute the element at``    ``// query index``    ``static` `int` `answer(``int``[] arr, ``int``[][] ranges,``                      ``int` `reversals, ``int` `index)``    ``{``        ``for` `(``int` `i = reversals - ``1``; i >= ``0``; i--) {``            ``// Range[left...right]``            ``int` `left = ranges[i][``0``],``                ``right = ranges[i][``1``];` `            ``// If doesn't satisfy, reversal``            ``// won't have any effect``            ``if` `(left <= index && right >= index)``                ``index = right + left - index;``        ``}` `        ``// Returning element at modified index``        ``return` `arr[index];``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``int``[] arr = { ``10``, ``20``, ``30``, ``40``, ``50` `};` `        ``// reversals``        ``int` `reversals = ``2``;``        ``int``[][] ranges = { { ``1``, ``4` `}, { ``0``, ``2` `} };` `        ``int` `index = ``1``;``        ``System.out.println(answer(arr, ranges,``                                  ``reversals, index));``    ``}``}` `/* This code is contributed by Mr. Somesh Awasthi */`

## Python3

 `# Program to find index of an element``# after given range reversals.` `# Function to compute the element``# at query index``def` `answer(arr, ranges, reversals, index):``    ``i ``=` `reversals ``-` `1``    ``while``(i >``=` `0``):``        ` `        ``# Range[left...right]``        ``left ``=` `ranges[i][``0``]``        ``right ``=` `ranges[i][``1``]` `        ``# If doesn't satisfy, reversal won't``        ``# have any effect``        ``if` `(left <``=` `index ``and` `right >``=` `index):``            ``index ``=` `right ``+` `left ``-` `index``    ` `        ``i ``-``=` `1``    ` `    ``# Returning element at modified index``    ``return` `arr[index]` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``10``, ``20``, ``30``, ``40``, ``50``]` `    ``# reversals``    ``reversals ``=` `2``    ``ranges ``=` `[ [ ``1``, ``4` `], [ ``0``, ``2` `] ]` `    ``index ``=` `1``    ``print``(answer(arr, ranges,``                 ``reversals, index))` `# This code is contributed by``# Surendra_Gangwar`

## C#

 `// C# program to find index of an element``// after given range reversals.``using` `System;` `class` `GFG {``    ` `    ``// Function to compute the element at``    ``// query index``    ``static` `int` `answer(``int``[] arr, ``int``[, ] ranges,``                       ``int` `reversals, ``int` `index)``    ``{``        ``for` `(``int` `i = reversals - 1; i >= 0; i--)``        ``{``            ` `            ``// Range[left...right]``            ``int` `left = ranges[i, 0],``                ``right = ranges[i, 1];` `            ``// If doesn't satisfy, reversal``            ``// won't have any effect``            ``if` `(left <= index && right >= index)``                ``index = right + left - index;``        ``}` `        ``// Returning element at modified index``        ``return` `arr[index];``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{` `        ``int``[] arr = { 10, 20, 30, 40, 50 };` `        ``// reversals``        ``int` `reversals = 2;``        ``int``[, ] ranges = { { 1, 4 }, { 0, 2 } };` `        ``int` `index = 1;``        ``Console.WriteLine(answer(arr, ranges,``                                ``reversals, index));``    ``}``}` `// This code is contributed by vt_m.`

## PHP

 `= 0; ``\$i``--)``    ``{``        ``// Range[left...right]``        ``\$left` `= ``\$ranges``[``\$i``][0];``        ``\$right` `= ``\$ranges``[``\$i``][1];` `        ``// If doesn't satisfy,``        ``// reversal won't have``        ``// any effect``        ``if` `(``\$left` `<= ``\$index` `&&``            ``\$right` `>= ``\$index``)``            ``\$index` `= ``\$right` `+ ``\$left` `-``                              ``\$index``;``    ``}` `    ``// Returning element``    ``// at modified index``    ``return` `\$arr``[``\$index``];``}` `// Driver Code``\$arr` `= ``array``( 10, 20, 30, 40, 50 );` `// reversals``\$reversals` `= 2;``\$ranges` `= ``array``(``array``( 1, 4 ),``                ``array``( 0, 2 ));` `\$index` `= 1;``echo` `answer(``\$arr``, ``\$ranges``,``            ``\$reversals``, ``\$index``);` `// This code is contributed``// by nitin mittal.``?>`

## Javascript

 ``

Output

`50`

Optimized solution

We can start by applying all the reversals to the array in the order they are given. To do this efficiently, we can use a helper function to reverse a given range of elements in the array. After applying all the reversals, we can answer the queries directly by accessing the element at the given index.

Algorithm

```First define function reverseRange(arr, L, R) that takes an array arr such that
a.Two indices L and R as input.
If L < R, THAN swap the elements at indices L and R in the array arr.
After that Increment L and decrement R.
Define a function applyReversals(arr, ranges)
For each pair of indices (L, R) in ranges, call the reverseRange function with arguments (arr, L, R).
Define a function getElementAtIndex(arr, index)
Return the element of arr at index index.
Initialize an array arr and a list of ranges ranges.
Call the applyReversals and getElementAtIndex function
Assign the result to variable result.
Get result as output.```

Implementation of above program

## C++

 `#include ``#include ``using` `namespace` `std;` `void` `reverseRange(vector<``int``>& arr, ``int` `L, ``int` `R) {``    ``while` `(L < R) {``        ``swap(arr[L], arr[R]);``        ``L++;``        ``R--;``    ``}``}` `void` `applyReversals(vector<``int``>& arr, vector>& ranges) {``    ``for` `(``int` `i = 0; i < ranges.size(); i++) {``        ``int` `L = ranges[i].first;``        ``int` `R = ranges[i].second;``        ``reverseRange(arr, L, R);``    ``}``}` `int` `getElementAtIndex(vector<``int``>& arr, ``int` `index) {``    ``return` `arr[index];``}` `int` `main() {``    ``// initialize inputs``    ``vector<``int``> arr = {10, 20, 30, 40, 50};``    ``vector> ranges = {{1, 4}, {0, 2}};``    ``int` `queryIndex = 1;` `    ``// apply reversals and answer query``    ``applyReversals(arr, ranges);``    ``int` `result = getElementAtIndex(arr, queryIndex);` `    ``// output result``    ``cout << result << endl;` `    ``return` `0;``}`

## Python

 `def` `reverseRange(arr, L, R):``    ``while` `L < R:``        ``arr[L], arr[R] ``=` `arr[R], arr[L]``        ``L ``+``=` `1``        ``R ``-``=` `1` `def` `applyReversals(arr, ranges):``    ``for` `L, R ``in` `ranges:``        ``reverseRange(arr, L, R)` `def` `getElementAtIndex(arr, index):``    ``return` `arr[index]` `# initialize inputs``arr ``=` `[``10``, ``20``, ``30``, ``40``, ``50``]``ranges ``=` `[(``1``, ``4``), (``0``, ``2``)]``queryIndex ``=` `1` `# apply reversals and answer query``applyReversals(arr, ranges)``result ``=` `getElementAtIndex(arr, queryIndex)` `# output result``print``(result)`

Output

`50`

Time complexity  O(N*M), where N is the length of the input array arr and M is the number of ranges in the input ranges.

Space complexity is O(1),as it does not use any additional memory.

This article is contributed by Rohit Thapliyal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up