# Find the Array element after Q queries based on the given conditions

Given an array **arr[]** of length **N** and **Q **queries of 3 types (1, 2, 3) whose operations are as follows:

**Type 1:**query has input as**1**and the task is to reverse the array.**Type 2:**query has input as**(2 x)**and the task to find the index of**x**in the result array.**Type 3:**query has input as**(3 x y)**and the task is to swap the elements at index**x**and**y**in the array.

The task is to print the result for the query of **type 2**.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.

**Examples:**

Input:N = 5, arr[] = {3, 7, 8, 1, 33}, Q = 4, Queries[][] = {{1}, {2, 8}, {3, 2, 4}, {2, 1}Output:2 1Explanation:Process query wise first is 1 so reverse the list [33, 1, 8, 7, 3], Second query 2 8 so find index of element 8 which is 2, third query is 3 2 4 so swap 2nd and 4th index new array=[33, 1, 3, 7, 8] now the last query is 2 1 so find index of element 1 which is 1 so output 2 1.

Input:N = 6, arr[] = {6, 33, 9, 22, 45, 4}, Q = 5, Queries[][] = {{1}, {3, 0, 4}, {2, 33}, {1}, {2, 9}}Output:0 2

**Approach:** The given problem can be solved based on the following assumptions for each query:

- Use a variable
**flag**=1 and for every query of type**1**, multiply**flag*****-1**so that for negative it indicates a reversal of list and manipulates the calculation in reverse order rather than directly reversing the array and this way reduces time complexity. - Now for the query of type
**3 x y**, use the map data structure to store index and element as key and value pairs and directly interchange the values in**O(1)**. - Finally for the query of type
**2 x**directly fetch the index.

Follow the steps below to solve the problem:

- Initialize a map
**mp = {}**to store the element and its index in the array as**key-value**pair. - Initialize the variable
**flag**as**1**to keep the track of the count of the number of times the array is reversed. - Iterate over the range
**[0, Q)**using the variable**i**and perform the following tasks:- First, check for the type of query while taking each query as input.
- For
**type 1**query instead of reversing manually which will increase time complexity, change the sign of the variable**flag**to denote array is normal or reversed. - For
**type 2**query, find the index of the given value from the map, and if the array is not reversed then print the value of**m[x]**as the result. Otherwise, print the value of**(N – m[x] – 1)**. - For
**type 3**query, first, find the values at given index and then swap the value and index in the list and map respectively.

Below is the implementation of the above approach:

## Python3

`# Python program for the above approach` ` ` `# Function to perform the given queries` `# and print the result accordingly` `def` `arrayManipulation(n, arr, q, qarr):` ` ` ` ` `# Stores the index value pair` ` ` `mp ` `=` `{}` ` ` `ans ` `=` `[]` ` ` ` ` `# Flag to indicate reversal` ` ` `flg ` `=` `1` ` ` `for` `i ` `in` `range` `(n):` ` ` `mp[arr[i]] ` `=` `i` ` ` ` ` `# Processing each query` ` ` `for` `i ` `in` `range` `(q):` ` ` `a ` `=` `qarr[i]` ` ` ` ` `# Type 1 flag multiplied -1` ` ` `if` `(a[` `0` `] ` `=` `=` `1` `):` ` ` `flg ` `*` `=` `-` `1` ` ` ` ` `# Type 2 query taking index` ` ` `# value acc. to flag sign` ` ` `elif` `(a[` `0` `] ` `=` `=` `2` `):` ` ` `x ` `=` `a[` `1` `]` ` ` `if` `(flg ` `=` `=` `-` `1` `):` ` ` `ans.append(n` `-` `mp[x]` `-` `1` `)` ` ` `else` `:` ` ` `ans.append(mp[x])` ` ` ` ` `# Type 3 query swaping value` ` ` `# directly in map` ` ` `else` `:` ` ` `x ` `=` `a[` `1` `]` ` ` `y ` `=` `a[` `2` `]` ` ` ` ` `# Stores the value to swap` ` ` `# and update the array` ` ` `x1 ` `=` `a[` `1` `]` ` ` `y1 ` `=` `a[` `2` `]` ` ` `if` `(flg ` `=` `=` `-` `1` `):` ` ` `y ` `=` `n` `-` `y` `-` `1` ` ` `x ` `=` `n` `-` `x` `-` `1` ` ` ` ` `# Value swapped and store` ` ` `# value to swap and update` ` ` `# the map` ` ` `y ` `=` `arr[y]` ` ` `x ` `=` `arr[x]` ` ` ` ` `# Index swapped` ` ` `arr[x1], arr[y1] ` `=` `arr[y1], arr[x1]` ` ` `mp[x], mp[y] ` `=` `mp[y], mp[x]` ` ` ` ` `# Print the result for queries` ` ` `print` `(` `*` `ans)` ` ` ` ` `# Driver Code` `N ` `=` `6` `arr ` `=` `[` `6` `, ` `33` `, ` `9` `, ` `22` `, ` `45` `, ` `4` `]` `Q ` `=` `5` `Queries ` `=` `[[` `1` `], [` `3` `, ` `0` `, ` `4` `], [` `2` `, ` `33` `], [` `1` `], [` `2` `, ` `9` `]]` ` ` `# Function Call` `arrayManipulation(N, arr, Q, Queries)` |

**Output:**

0 2

**Time Complexity:** O(max(N, Q))**Auxiliary Space:** O(N)