Find the Array element after Q queries based on the given conditions
Last Updated :
23 Feb, 2023
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
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);
}
}
# 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# 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 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__
Time Complexity: O(max(N, Q))
Auxiliary Space: O(N)
Similar Reads
Largest interval in an Array that contains the given element X for Q queries Given an array arr[] of N elements and Q queries of the form [X]. For each query, the task is to find the largest interval [L, R] of the array such that the greatest element in the interval is arr[X], such that 1 ? L ? X ? R. Note: The array has 1-based indexing. Examples: Input: N = 5, arr[] = {2,
10 min read
Minimum steps to reach a given index in the Array based on given conditions Given an array arr[ ] of size N consisting of integers -1, 0, 1 only and an array q[ ] consisting of queries. In the array arr[ ], -1 signifies that any index to the left of it is reachable and 1 signifies that any index to the right of it is reachable from that index. The index in a particular quer
10 min read
Queries to update array elements in a range [L, R] to satisfy given conditions Given an array arr[] consisting of N 0s and an array Q[][] with each row of the form (L, R)., the task for each query is to update all the array elements in the range [L, R] such that arr[i] = i - L + 1. Examples: Input: arr[] = { 0, 0, 0, 0 }, Q[][] = { { 1, 2 }, { 0, 1 } } Output: 1 3 2 0 Explanat
9 min read
Range sum queries based on given conditions Given an array arr[] of N integers and matrix Queries[][] consisting of Q queries of the form {m, a, b}. For each query the task is to find the sum of array elements according to the following conditions: If m = 1: Find the sum of the array elements in the range [a, b].If m = 2: Rearrange the array
15+ min read
Find the minimum range size that contains the given element for Q queries Given an array Intervals[] consisting of N pairs of integers where each pair is denoting the value range [L, R]. Also, given an integer array Q[] consisting of M queries. For each query, the task is to find the size of the smallest range that contains that element. Return -1 if no valid interval exi
12 min read