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.

Examples:

Input: N = 5, arr[] = {3, 7, 8, 1, 33}, Q = 4, Queries[][] = {{1}, {2, 8}, {3, 2, 4}, {2, 1}
Output: 2 1
Explanation: 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:

C++

// C++ program for the above approach

// Function to perform the given queries
// and print the result accordingly
#include<bits/stdc++.h>
using namespace std;

void arrayManipulation(int n,vector<int> arr,int q,vector<vector<int>> qarr){

    // Stores the index value pair
    unordered_map<int,int>mp;
    vector<int>ans;

    // Flag to indicate reversal
    int flg = 1;
    for(int i=0;i<n;i++){
        mp[arr[i]] = i;
    }

    // Processing each query
    for(int i=0;i<q;i++){
        vector<int>a = qarr[i];

        // Type 1 flag multiplied -1
        if(a[0] == 1)
            flg *= -1;

        // Type 2 query taking index
        // value acc. to flag sign
        else if(a[0] == 2){
            int x = a[1];
            if(flg == -1)
                ans.push_back(n-mp[x]-1);
            else
                ans.push_back(mp[x]);
        }

        // Type 3 query swapping value
        // directly in map
        else{
            int x = a[1];
            int y = a[2];

            // Stores the value to swap
            // and update the array
            int x1 = a[1];
            int 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
            swap(arr[x1],arr[y1]);
            swap(mp[x],mp[y]);
        }
    }

    // Print the result for queries
    for(auto x:ans){
        cout<<x<<" ";
    }

}

// Driver Code
int main(){

int N = 6;
vector<int> arr = {6, 33, 9, 22, 45, 4};
int Q = 5;
vector<vector<int>>Queries = {{1}, {3, 0, 4}, {2, 33}, {1}, {2, 9}};

// Function Call
arrayManipulation(N, arr, Q, Queries);

}

// This code is contributed by shinjanpatra

Java

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;

class Main {

    // Function to perform the given queries
    // and print the result accordingly
    public static void arrayManipulation(int n, List<Integer> arr,
                                         int q, List<List<Integer>> qarr) {

        // Stores the index value pair
        HashMap<Integer, Integer> mp = new HashMap<Integer, Integer>();
        ArrayList<Integer> ans = new ArrayList<Integer>();

        // Flag to indicate reversal
        int flg = 1;
        for (int i = 0; i < n; i++) {
            mp.put(arr.get(i), i);
        }

        // Processing each query
        for (int i = 0; i < q; i++) {
            List<Integer> a = qarr.get(i);

            // Type 1 flag multiplied -1
            if (a.get(0) == 1)
                flg *= -1;

            // Type 2 query taking index
            // value acc. to flag sign
            else if (a.get(0) == 2) {
                int x = a.get(1);
                if (flg == -1)
                    ans.add(n - mp.get(x) - 1);
                else
                    ans.add(mp.get(x));
            }

            // Type 3 query swapping value
            // directly in map
            else {
                int x = a.get(1);
                int y = a.get(2);

                // Stores the value to swap
                // and update the array
                int x1 = a.get(1);
                int y1 = a.get(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.get(y);
                x = arr.get(x);

                // Index swapped
                int temp = arr.get(x1);
                arr.set(x1, arr.get(y1));
                arr.set(y1, temp);
                mp.put(x, mp.get(y));
                mp.put(y, temp);
            }
        }

        // Print the result for queries
        for (int x : ans) {
          if(x==-1) x = 0;
            System.out.print(x + " ");
        }
    }

    // Driver Code
    public static void main(String[] args) {
        int N = 6;
        List<Integer> arr =
          new ArrayList<Integer>(Arrays.asList(6, 33, 9, 22, 45, 4));
        int Q = 5;
        List<List<Integer>> Queries = new ArrayList<List<Integer>>();
        Queries.add(new ArrayList<Integer>(Arrays.asList(1)));
        Queries.add(new ArrayList<Integer>(Arrays.asList(3, 0, 4)));
        Queries.add(new ArrayList<Integer>(Arrays.asList(2, 33)));
        Queries.add(new ArrayList<Integer>(Arrays.asList(1)));
        Queries.add(new ArrayList<Integer>(Arrays.asList(2, 9)));

        // Function Call
        arrayManipulation(N, arr, Q, Queries);
    }
}

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 swapping 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)

C#

// C# program for the above approach
using System;
using System.Collections.Generic;

class Program
{
  static void ArrayManipulation(int n, int[] arr, int q, int[][] qarr)
  {

    // Stores the index value pair
    Dictionary<int, int> mp = new Dictionary<int, int>();
    List<int> ans = new List<int>();

    // Flag to indicate reversal
    int flg = 1;
    for (int i = 0; i < n; i++)
    {
      mp[arr[i]] = i;
    }

    // Processing each query
    for (int i = 0; i < q; i++)
    {
      int[] a = qarr[i];

      // Type 1 flag multiplied -1
      if (a[0] == 1)
        flg *= -1;

      // Type 2 query taking index
      // value acc. to flag sign
      else if (a[0] == 2)
      {
        int x = a[1];
        if (flg == -1)
          ans.Add(n - mp[x] - 1);
        else
          ans.Add(mp[x]);
      }

      // Type 3 query swapping value
      // directly in map
      else
      {
        int x = a[1];
        int y = a[2];

        // Stores the value to swap
        // and update the array
        int x1 = a[1];
        int 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
        int temp = arr[x1];
        arr[x1] = arr[y1];
        arr[y1] = temp;

        int temp2 = mp[x];
        mp[x] = mp[y];
        mp[y] = temp2;
      }
    }

    // Print the result for queries
    Console.WriteLine(string.Join(" ", ans));
  }

  static void Main(string[] args)
  {
    int N = 6;
    int[] arr = { 6, 33, 9, 22, 45, 4 };
    int Q = 5;
    int[][] Queries = { new int[] { 1 }, new int[] { 3, 0, 4 }, new int[] { 2, 33 }, new int[] { 1 }, new int[] { 2, 9 } };

    // Function Call
    ArrayManipulation(N, arr, Q, Queries);
  }
}

// This code is contributed by shivamsharma215

Javascript

// JavaScript program for the above approach

// Function to perform the given queries
// and print the result accordingly
function arrayManipulation(n, arr, q, qarr) {

    // Stores the index value pair
    let mp = {};
    let ans = [];

    // Flag to indicate reversal
    let flg = 1;
    for (let i = 0; i < n; i++) {
        mp[arr[i]] = i;
    }

    // Processing each query
    for (let i = 0; i < q; i++) {
        let a = qarr[i];

        // Type 1 flag multiplied -1
        if (a[0] == 1) {
            flg *= -1;

        // Type 2 query taking index
        // value acc. to flag sign
        } else if (a[0] == 2) {
            let x = a[1];
            if (flg == -1) {
                ans.push(n - mp[x] - 1);
            } else {
                ans.push(mp[x]);
            }

        // Type 3 query swapping value
        // directly in map
        } else {
            let x = a[1];
            let y = a[2];

            // Stores the value to swap
            // and update the array
            let x1 = a[1];
            let 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
            let temp = arr[x1];
            arr[x1] = arr[y1];
            arr[y1] = temp;

            let temp2 = mp[x];
            mp[x] = mp[y];
            mp[y] = temp2;
        }
    }

    // Print the result for queries
    console.log(...ans);

}

// Driver Code
let N = 6;
let arr = [6, 33, 9, 22, 45, 4];
let Q = 5;
let Queries = [[1], [3, 0, 4], [2, 33], [1], [2, 9]];

// Function Call
arrayManipulation(N, arr, Q, Queries);

// This code is contributed by akashish__

Output:

0 2

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