Array Queries for multiply, replacements and product

• Difficulty Level : Easy
• Last Updated : 09 Sep, 2021

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.

C++

 // C++ program to solve three types of queries.#include using namespace std; //vector of 1000 elements,//all set to 0vector twos(1000,0); //vector of 1000 elements,//all set to 0vector fives(1000,0); int sum = 0; // Function to check number of// trailing zeros in multiple of 2int 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 5int returnFives(int val){    int count = 0;    while (val % 5 == 0 && val != 0) {         val = val / 5;        count++;    }     return count;} // Function to solve the queries receivedvoid 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 codeint 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

 // 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 0static int twos[] = new int; // Vector of 1000 elements,// all set to 0static int fives[] = new int; static int sum = 0; // Function to check number of// trailing zeros in multiple of 2static 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 5static int returnFives(int val){    int count = 0;    while (val % 5 == 0 && val != 0)    {        val = val / 5;        count++;    }    return count;} // Function to solve the queries receivedstatic 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 codepublic 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

 # Python3 program to solve three types of queries. # vector of 1000 elements,# all set to 0twos =  * 1000 # vector of 1000 elements,# all set to 0fives =  * 1000 sum = 0 # Function to check number of# trailing zeros in multiple of 2def 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 5def returnFives(val):         count = 0    while (val % 5 == 0 and val != 0):        val = val // 5        count += 1             return count # Function to solve the queries receiveddef solve_queries(arr, n):         global sum    arrr1 = list(map(int,input().split()))    type = arrr1         # If the query is of type 1.    if (type == 1):        ql, qr, x = arrr1, arrr1, arrr1                 # 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, arrr1, arrr1                 # 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, arrr1        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 queriesn, 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 querieswhile (m):    m -= 1    solve_queries(arr, n) print(sum) # This code is contributed by SHUBHAMSINGH10

Input:

5 5
2 4 3 5 5
3 2 4
3 2 5
2 2 4 1
1 3 3 10
3 1 5

Output:

5

The complexity of this code is O(n*q).

For each query, it is taking O(n) so the final time complexity is O(n*q)
This article is contributed by Mohak Agrawal. 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.