Array Queries for multiply, replacements and product
Last Updated :
27 Apr, 2023
This is Range query question in which we have been provided with and array of size N. Given are 3 types of queries and you have to answer M number of specified queries.
- Type 1 query :You will be given 3 values in the form of L R X and in this type of query to have to multiply x to the array elements inclusive in the range L to R.
- Type 2 query :In this query also you will be given 3 values in the form of L R Y and after executing this type of query you will replace the array elements in the form that the first element is replaced by Y, the second element is replaced by 2*Y and as follows inclusive in the range L to R.
- Type 3 query : In this you will be given 2 value L and R and in this you have to
find the product of all numbers in the range. As this number could be very large, you have to just find the number of trailing zeros of this number when represented in decimal notation.
Examples:
Input : arr[] = {2, 4, 3, 5, 5|
queries[] = {{3 2 4}, {3 2 5}, {2 2 4 1},
{1 3 3 10}, {3 1 5}}
Output : 5
Explanation :
Since the first query is of type 3 so we multiply
the elements 4 * 3 * 5 = 60.
Since the second query is of type 3 so we multiply
the elements 4 * 3 * 5 * 5 = 300.
Since the third query is of type 2 and the value of
Y is 1 so after execution of this query the array
becomes [2, 1, 2, 3, 5].
Since the fourth query is of type 1 and the value of
x is 10 so after execution of this query the array
becomes [2, 1, 20, 3, 5].
Now the last query is of type 3 then we simply multiply
all the elements inclusive in the given range i.e.
2 * 1 * 20 * 3 * 5 = 600.
Now our task is to calculate the trailing zeros obtained
in the type 3 query i.e. 60 has 1 trailing zero, 300 has
2 trailing zeros and 600 has 2 trailing zeros so the
answer of this given input is 5.
Method 1: In this we can simply apply the Brute force method. In the brute force method we will apply all the operation in the array elements and for every type 3 query we will store the obtained result in a new array then we will calculate the number of trailing zeros for every result thus obtained and then calculate the desired sum.
The complexity of this method will be O(m*n) as we will operate the entire array m times for the given m queries and an extra space of size m will be required to save the results obtained in the type 3 queries for calculating the number of trailing zeros after execution of m queries.
So, time complexity is O(m*n) and space complexity is O(m).
Method 2: In this method we have 2 vectors because a number with trailing zero can be multiple of 10 and 10 is a multiple of 2 and 5 so two separate vectors have been maintained for this purpose. And the rest has been explained below.
Implementation:
C++
// C++ program to solve three types of queries.
#include <bits/stdc++.h>
using namespace std;
//vector of 1000 elements,
//all set to 0
vector<int> twos(1000,0);
//vector of 1000 elements,
//all set to 0
vector<int> fives(1000,0);
int sum = 0;
// Function to check number of
// trailing zeros in multiple of 2
int returnTwos(int val)
{
int count = 0;
while (val % 2 == 0 && val != 0) {
val = val / 2;
count++;
}
return count;
}
// Function to check number of
// trailing zeros in multiple of 5
int returnFives(int val)
{
int count = 0;
while (val % 5 == 0 && val != 0) {
val = val / 5;
count++;
}
return count;
}
// Function to solve the queries received
void solve_queries(int arr[], int n)
{
int type, ql, qr, x, y;
cin >> type;
// If the query is of type 1.
if (type == 1) {
cin >> ql >> qr >> x;
// Counting the number of
// zeros in the given value of x
int temp = returnTwos(x);
int temp1 = returnFives(x);
for (int i = ql - 1; i < qr; i++) {
// The value x has been multiplied
// to their respective indices
arr[i] = arr[i] * x;
// The value obtained above has been
// added to their respective vectors
twos[i] += temp;
fives[i] += temp1;
}
}
// If the query is of type 2.
if (type == 2) {
cin >> ql >> qr >> y;
// Counting the number of
// zero in the given value of x
int temp = returnTwos(y);
int temp1 = returnFives(y);
for (int i = ql - 1; i < qr; i++) {
// The value y has been replaced
// to their respective indices
arr[i] = (i - ql + 2) * y;
// The value obtained above has been
// added to their respective vectors
twos[i] = returnTwos(i - ql + 2) + temp;
fives[i] = returnFives(i - ql + 2) + temp1;
}
}
// If the query is of type 2
if (type == 3) {
cin >> ql >> qr;
int sumtwos = 0;
int sumfives = 0;
for (int i = ql - 1; i < qr; i++) {
// as the number of trailing zeros for
// each case has been found for each array
// element then we simply add those to
// the respective index to a variable
sumtwos += twos[i];
sumfives += fives[i];
}
// Compare the number of zeros
// obtained in the multiples of five and two
// consider the minimum of them and add them
sum += min(sumtwos, sumfives);
}
}
// Driver code
int main()
{
int n, m;
// Input the Size of array
// and number of queries
cin >> n >> m;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
twos[i] = returnTwos(arr[i]);
fives[i] = returnFives(arr[i]);
}
// Running the while loop
// for m number of queries
while (m--) {
solve_queries(arr, n);
}
cout << sum << endl;
return 0;
}
// Java program to solve three types of queries.
import java.io.*;
import java.util.*;
import java.util.Arrays;
class GFG{
static Scanner sc= new Scanner(System.in);
// Vector of 1000 elements,
// all set to 0
static int twos[] = new int[1000];
// Vector of 1000 elements,
// all set to 0
static int fives[] = new int[1000];
static int sum = 0;
// Function to check number of
// trailing zeros in multiple of 2
static int returnTwos(int val)
{
int count = 0;
while (val % 2 == 0 && val != 0)
{
val = val / 2;
count++;
}
return count;
}
// Function to check number of
// trailing zeros in multiple of 5
static int returnFives(int val)
{
int count = 0;
while (val % 5 == 0 && val != 0)
{
val = val / 5;
count++;
}
return count;
}
// Function to solve the queries received
static void solve_queries(int arr[], int n)
{
int type = sc.nextInt();
// If the query is of type 1.
if (type == 1)
{
int ql = sc.nextInt();
int qr = sc.nextInt();
int x = sc.nextInt();
// Counting the number of
// zeros in the given value of x
int temp = returnTwos(x);
int temp1 = returnFives(x);
for(int i = ql - 1; i < qr; i++)
{
// The value x has been multiplied
// to their respective indices
arr[i] = arr[i] * x;
// The value obtained above has been
// added to their respective vectors
twos[i] += temp;
fives[i] += temp1;
}
}
// If the query is of type 2.
if (type == 2)
{
int ql = sc.nextInt();
int qr = sc.nextInt();
int y = sc.nextInt();
// Counting the number of
// zero in the given value of x
int temp = returnTwos(y);
int temp1 = returnFives(y);
for(int i = ql - 1; i < qr; i++)
{
// The value y has been replaced
// to their respective indices
arr[i] = (i - ql + 2) * y;
// The value obtained above has been
// added to their respective vectors
twos[i] = returnTwos(i - ql + 2) + temp;
fives[i] = returnFives(i - ql + 2) + temp1;
}
}
// If the query is of type 2
if (type == 3)
{
int ql = sc.nextInt();
int qr = sc.nextInt();
int sumtwos = 0;
int sumfives = 0;
for(int i = ql - 1; i < qr; i++)
{
// As the number of trailing zeros for
// each case has been found for each array
// element then we simply add those to
// the respective index to a variable
sumtwos += twos[i];
sumfives += fives[i];
}
// Compare the number of zeros
// obtained in the multiples of five and two
// consider the minimum of them and add them
sum += Math.min(sumtwos, sumfives);
}
}
// Driver code
public static void main(String[] args)
{
// Input the Size of array
// and number of queries
int n = sc.nextInt();
int m = sc.nextInt();
int arr[] = new int[n];
for(int i = 0; i < n; i++)
{
arr[i] = sc.nextInt();
twos[i] = returnTwos(arr[i]);
fives[i] = returnFives(arr[i]);
}
// Running the while loop
// for m number of queries
while (m-- != 0)
{
solve_queries(arr, n);
}
System.out.println(sum);
}
}
// This code is contributed by SHUBHAMSINGH10
# Python3 program to solve three types of queries.
# vector of 1000 elements,
# all set to 0
twos = [0] * 1000
# vector of 1000 elements,
# all set to 0
fives = [0] * 1000
sum = 0
# Function to check number of
# trailing zeros in multiple of 2
def returnTwos(val):
count = 0
while (val % 2 == 0 and val != 0):
val = val // 2
count += 1
return count
# Function to check number of
# trailing zeros in multiple of 5
def returnFives(val):
count = 0
while (val % 5 == 0 and val != 0):
val = val // 5
count += 1
return count
# Function to solve the queries received
def solve_queries(arr, n):
global sum
arrr1 = list(map(int,input().split()))
type = arrr1[0]
# If the query is of type 1.
if (type == 1):
ql, qr, x = arrr1[1], arrr1[2], arrr1[3]
# Counting the number of
# zeros in the given value of x
temp = returnTwos(x)
temp1 = returnFives(x)
i = ql - 1
while(i < qr):
# The value x has been multiplied
# to their respective indices
arr[i] = arr[i] * x
# The value obtained above has been
# added to their respective vectors
twos[i] += temp
fives[i] += temp1
i += 1
# If the query is of type 2.
if (type == 2):
ql, qr, y = arrr1[1], arrr1[2], arrr1[3]
# Counting the number of
# zero in the given value of x
temp = returnTwos(y)
temp1 = returnFives(y)
i = ql - 1
while(i < qr):
# The value y has been replaced
# to their respective indices
arr[i] = (i - ql + 2) * y
# The value obtained above has been
# added to their respective vectors
twos[i] = returnTwos(i - ql + 2) + temp
fives[i] = returnFives(i - ql + 2) + temp1
i += 1
# If the query is of type 2
if (type == 3):
ql, qr = arrr1[1], arrr1[2]
sumtwos = 0
sumfives = 0
i = ql - 1
while(i < qr):
# As the number of trailing zeros for
# each case has been found for each array
# element then we simply add those to
# the respective index to a variable
sumtwos += twos[i]
sumfives += fives[i]
i += 1
# Compare the number of zeros
# obtained in the multiples of five and two
# consider the minimum of them and add them
sum += min(sumtwos, sumfives)
# Driver code
# Input the Size of array
# and number of queries
n, m = map(int, input().split())
arr = list(map(int, input().split()))
for i in range(n):
twos[i] = returnTwos(arr[i])
fives[i] = returnFives(arr[i])
# Running the while loop
# for m number of queries
while (m):
m -= 1
solve_queries(arr, n)
print(sum)
# This code is contributed by SHUBHAMSINGH10
// C# program to solve three types of queries.
using System;
public class HelloWorld
{
// Array of 1000 elements,
// all set to 0
static int[] twos=new int[1000];
// Array of 1000 elements,
// all set to 0
static int[] fives=new int[1000];
static int sum = 0;
// Function to check number of
// trailing zeros in multiple of 2
static int returnTwos(int val)
{
int count = 0;
while (val % 2 == 0 && val != 0) {
val = val / 2;
count++;
}
return count;
}
// Function to check number of
// trailing zeros in multiple of 5
static int returnFives(int val)
{
int count = 0;
while (val % 5 == 0 && val != 0) {
val = val / 5;
count++;
}
return count;
}
// Function to solve the queries received
static void solve_queries(int []arr, int n)
{
int type, ql, qr, x, y;
type = Convert.ToInt32(Console.ReadLine());
// If the query is of type 1.
if (type == 1) {
ql = Convert.ToInt32(Console.ReadLine());
qr = Convert.ToInt32(Console.ReadLine());
x = Convert.ToInt32(Console.ReadLine());
// Counting the number of
// zeros in the given value of x
int temp = returnTwos(x);
int temp1 = returnFives(x);
for (int i = ql - 1; i < qr; i++) {
// The value x has been multiplied
// to their respective indices
arr[i] = arr[i] * x;
// The value obtained above has been
// added to their respective vectors
twos[i] += temp;
fives[i] += temp1;
}
}
// If the query is of type 2.
if (type == 2) {
ql = Convert.ToInt32(Console.ReadLine());
qr = Convert.ToInt32(Console.ReadLine());
y = Convert.ToInt32(Console.ReadLine());
// Counting the number of
// zero in the given value of x
int temp = returnTwos(y);
int temp1 = returnFives(y);
for (int i = ql - 1; i < qr; i++) {
// The value y has been replaced
// to their respective indices
arr[i] = (i - ql + 2) * y;
// The value obtained above has been
// added to their respective vectors
twos[i] = returnTwos(i - ql + 2) + temp;
fives[i] = returnFives(i - ql + 2) + temp1;
}
}
// If the query is of type 3
if (type == 3) {
ql = Convert.ToInt32(Console.ReadLine());
qr = Convert.ToInt32(Console.ReadLine());
int sumtwos = 0;
int sumfives = 0;
for (int i = ql - 1; i < qr; i++) {
// as the number of trailing zeros for
// each case has been found for each array
// element then we simply add those to
// the respective index to a variable
sumtwos += twos[i];
sumfives += fives[i];
}
// Compare the number of zeros
// obtained in the multiples of five and two
// consider the minimum of them and add them
sum += Math.Min(sumtwos, sumfives);
}
}
public static void Main(string[] args)
{
int n=5, m=5;
int[] arr = { 2, 4, 3, 5, 5 };
for (int i = 0; i < 1000; i++)
{
twos[i] = 0;
fives[i] = 0;
}
for (int i = 0; i < n; i++) {
twos[i] = returnTwos(arr[i]);
fives[i] = returnFives(arr[i]);
}
// Running the while loop
// for m number of queries
while (m > 0) {
solve_queries(arr, n);
m=m-1;
}
Console.WriteLine(sum);
}
}
// This code is contributed by Aarti_Rathi
<script>
//vector of 1000 elements,
//all set to 0
let twos = [];
//vector of 1000 elements,
//all set to 0
let fives = [];
let sum = 0;
// Function to check number of
// trailing zeros in multiple of 2
function returnTwos(val)
{
let count = 0;
while (val % 2 == 0 && val != 0) {
val = val / 2;
count++;
}
return count;
}
// Function to check number of
// trailing zeros in multiple of 5
function returnFives(val)
{
var count = 0;
while (val % 5 == 0 && val != 0) {
val = val / 5;
count++;
}
return count;
}
// Function to solve the queries received
function solve_queries(arr, n)
{
var type, ql, qr, x, y;
type = prompt();
// If the query is of type 1.
if (type == 1) {
ql = prompt();
qr = prompt();
x = prompt();
// Counting the number of
// zeros in the given value of x
var temp = returnTwos(x);
var temp1 = returnFives(x);
for (var i = ql - 1; i < qr; i++) {
// The value x has been multiplied
// to their respective indices
arr[i] = arr[i] * x;
// The value obtained above has been
// added to their respective vectors
twos[i] += temp;
fives[i] += temp1;
}
}
// If the query is of type 2.
if (type == 2) {
ql = prompt();
qr = prompt();
y = prompt();
// Counting the number of
// zero in the given value of x
var temp = returnTwos(y);
var temp1 = returnFives(y);
for (var i = ql - 1; i < qr; i++) {
// The value y has been replaced
// to their respective indices
arr[i] = (i - ql + 2) * y;
// The value obtained above has been
// added to their respective vectors
twos[i] = returnTwos(i - ql + 2) + temp;
fives[i] = returnFives(i - ql + 2) + temp1;
}
}
// If the query is of type 2
if (type == 3) {
ql = prompt();
qr = prompt();
var sumtwos = 0;
var sumfives = 0;
for (var i = ql - 1; i < qr; i++) {
// as the number of trailing zeros for
// each case has been found for each array
// element then we simply add those to
// the respective index to a variable
sumtwos += twos[i];
sumfives += fives[i];
}
// Compare the number of zeros
// obtained in the multiples of five and two
// consider the minimum of them and add them
sum += Math.min(sumtwos, sumfives);
}
}
// This code is contributed by Aarti_Rathi
// Driver code
var n = prompt();
var m = prompt();
var arr = [];
for(var i=0; i<n; i++)
{
arr[i] = prompt();
twos[i] = returnTwos(arr[i]);
fives[i] = returnFives(arr[i]);
}
// Running the while loop
// for m number of queries
while (m--) {
solve_queries(arr, n);
}
document.write(sum)
// This code is contributed by Aarti_Rathi
</script>
Time complexity: O(n*qlogn).
Auxiliary space: O(k) where k=1000.
For each query, it is taking O(nlogn) so the final time complexity is O(n*q)
Similar Reads
Range product queries in an array
We have an array of integers and a set of range queries. For every query, we need to find product of elements in the given range. Example: Input : arr[] = {5, 10, 15, 20, 25} queries[] = {(3, 5), (2, 2), (2, 3)} Output : 7500, 10, 150 7500 = 15 x 20 x 25 10 = 10 150 = 10 x 15 A naive approach would
10 min read
A product array puzzle | Set 2 (O(1) Space)
Given an array arr[] of size n, construct a product array res[] (of the same size) such that res[i] is equal to the product of all the elements of arr[] except arr[i]. Note: Solve it without division operator and in O(n).Examples: Input: arr[] = [10, 3, 5, 6, 2]Output: [180, 600, 360, 300, 900]Expla
13 min read
Replace every array element by multiplication of previous and next
Given an array of integers, update every element with the multiplication of previous and next elements with the following exceptions. a) The First element is replaced by the multiplication of the first and second. b) The last element is replaced by multiplication of the last and second last. Example
7 min read
Product of all Subarrays of an Array
Given an array of integers arr of size N, the task is to print products of all subarrays of the array. Examples: Input: arr[] = {2, 4} Output: 64 Here, subarrays are [2], [2, 4], [4] Products are 2, 8, 4 Product of all Subarrays = 64 Input : arr[] = {10, 3, 7} Output : 27783000 Here, subarrays are [
7 min read
Multiply Large Numbers represented as Strings
Given two numbers as strings s1 and s2, calculate their product. Note: The numbers can be negative and you are not allowed to use any built-in function or convert the strings to integers. There can be zeros in the beginning of the numbers. You don't need to specify '+' sign in the beginning of posit
12 min read
Multiplication on Array : Range update query in O(1)
Consider an array A[] of integers and the following two types of queries. update(l, r, x): multiply x to all values from A[l] to A[r] (both inclusive).printArray(): Prints the current modified array. Examples: Input: A[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1} update(0, 2, 2) update(1, 4, 3) print() update
7 min read
Product of maximum in first array and minimum in second
Given two arrays, the task is to calculate the product of max element of first array and min element of second array References : Asked in Adobe (Source : Careercup) Examples : Input : arr1[] = {5, 7, 9, 3, 6, 2}, arr2[] = {1, 2, 6, -1, 0, 9} Output : max element in first array is 9 and min element
15 min read
Queries to find maximum product pair in range with updates
You are given an array arr[] of positive integers. Your task is to process q queries, each consisting of three integers, of the following two types:[1, L, R]: Find the maximum product of any two distinct elements in the subarray arr[L…R] (inclusive).[2, i, val]: Update the element at index i to val
15+ min read
Maximum product quadruple (sub-sequence of size 4) in array
Given an integer array, find a maximum product of a quadruple in the array. Examples: Input: [10, 3, 5, 6, 20] Output: 6000 Multiplication of 10, 5, 6 and 20 Input: [-10, -3, -5, -6, -20] Output: 6000 Input: [1, -4, 3, -6, 7, 0] Output: 504 Approach 1 (Naive, O( ) time, O(1) Space) Steps to solve th
15+ min read
A Product Array Puzzle | Set 3
Given an array arr[] consisting of N integers, the task is to construct a Product array of the same size without using division ('/') operator such that each array element becomes equal to the product of all the elements of arr[] except arr[i]. Examples: Input: arr[] = {10, 3, 5, 6, 2}Output: 180 60
10 min read