# Print the Array of size N containing values in range [0, M) after Q query updates

• Difficulty Level : Easy
• Last Updated : 06 Jan, 2022

Given array arr[] of size N containing cyclic variables having states from 0 to (M – 1) (i.e when incremented from M-1 it goes to 0). The task is to fulfill the Q queries of which are of any of the following two types:

• 1st Type: 1 L R K – increment all the values in range of indices [L, R], K times cyclically.
• 2nd Type: 2 L R – print the updated values in range of indices [L, R].

Examples:

Input: arr[] = {2, 2, 7, 2, 5}, Q = 5, M = 8
queries[][] = {{1, 0, 3, 4},
{1, 4, 4, 2},
{1, 0, 0, 7},
{2, 1, 3},
{2, 3, 3}}
Output: {6, 3, 6}, {6}
Explanation: The states after performing each operation are:
After 1st: {6, 6, 3, 6, 5}
After 2nd: {6, 6, 3, 6, 7}
After 3rd: {5, 6, 3, 6, 7}
So in 4th query elements from index 1 to 3 and in 5th query element in index 3 are printed.

Input: arr[] = [2, 3, 4, 5], Q = 3, M = 6
queries[][] = {{1, 0, 0, 3},
{1, 1, 2, 2},
{1, 3, 3, 1},
{2, 0, 3}}
Output: {5, 5, 1, 1}

Approach: The problem can be solved using greedy approach. Follow the steps mentioned below to implement the approach:

• When a query is of first type update all the values in range [L, R], K times.
• When a query is of second type then print the value in range [L, R].

Below is the implementation of the above approach.

## C++14

 `// C++ code to implement above approach` `#include ` `using` `namespace` `std;`   `// Function to implement the queries` `void` `update(``int` `arr[], ``int` `N, ``int` `M, ``int` `Q,` `            ``vector >& queries)` `{` `    ``// Loop to implement the queries` `    ``for` `(``int` `i = 0; i < Q; i++) {` `        ``if` `(queries[i] == 1) {` `            ``for` `(``int` `j = queries[i]; ` `                 ``j <= queries[i];` `                 ``j++)` `                ``arr[j] = (arr[j] + ` `                          ``queries[i]) % M;` `        ``}` `        ``else` `if` `(queries[i] == 2) {` `            ``for` `(``int` `j = queries[i]; ` `                 ``j <= queries[i];` `                 ``j++)` `                ``cout << arr[j] << ``" "``;` `            ``cout << endl;` `        ``}` `    ``}` `}`   `// Driver's code` `int` `main()` `{` `    ``int` `N = 5, M = 8, Q = 5;` `    ``int` `arr[] = { 2, 2, 7, 2, 5 };` `    ``vector > queries(Q);` `    ``queries = { 1, 0, 3, 4 };` `    ``queries = { 1, 4, 4, 2 };` `    ``queries = { 1, 0, 0, 7 };` `    ``queries = { 2, 1, 3 };` `    ``queries = { 2, 3, 3 };`   `    ``update(arr, N, M, Q, queries);` `    ``return` `0;` `}`

## Java

 `// Java code to implement the above approach` `import` `java.io.*;` `class` `GFG {`   `  ``// Function to implement the queries` `  ``public` `static` `void` `update(``int``[] arr, ``int` `N, ``int` `M,` `                            ``int` `Q, ``int``[][] queries)` `  ``{`   `    ``// Loop to implement the queries` `    ``for` `(``int` `i = ``0``; i < Q; i++) {` `      ``if` `(queries[i][``0``] == ``1``) {` `        ``for` `(``int` `j = queries[i][``1``]; ` `             ``j <= queries[i][``2``];` `             ``j++)` `          ``arr[j] = (arr[j] + ` `                    ``queries[i][``3``]) % M;` `      ``}` `      ``else` `if` `(queries[i][``0``] == ``2``) {` `        ``for` `(``int` `j = queries[i][``1``]; ` `             ``j <= queries[i][``2``];` `             ``j++)` `          ``System.out.print(arr[j]+ ``" "``);` `        ``System.out.println();` `      ``}` `    ``}` `  ``}`   `  ``// Driver's code` `  ``public` `static` `void` `main (String[] args)` `  ``{` `    ``int` `N = ``5``, M = ``8``, Q = ``5``;` `    ``int``[] arr = { ``2``, ``2``, ``7``, ``2``, ``5` `};` `    ``int``[][] queries = ``new` `int``[][] ` `    ``{` `      ``new` `int``[] { ``1``, ``0``, ``3``, ``4` `},` `      ``new` `int``[] { ``1``, ``4``, ``4``, ``2` `},` `      ``new` `int``[] { ``1``, ``0``, ``0``, ``7` `},` `      ``new` `int``[] { ``2``, ``1``, ``3` `},` `      ``new` `int``[] { ``2``, ``3``, ``3` `}` `    ``};` `    ``update(arr, N, M, Q, queries);` `  ``}` `}`   `// This code is contributed by Shubham Singh`

## Python3

 `# Python3 code to implement above approach`   `# Function to implement the queries` `def` `update(arr, N, M,  Q, queries):`   `    ``# Loop to implement the queries` `    ``for` `i ``in` `range``(Q):` `        ``if` `(queries[i][``0``] ``=``=` `1``):` `            ``for` `j ``in` `range``(queries[i][``1``],` `                           ``queries[i][``2``] ``+` `1``):`   `                ``arr[j] ``=` `(arr[j] ``+` `                          ``queries[i][``3``]) ``%` `M`   `        ``elif` `(queries[i][``0``] ``=``=` `2``):` `            ``for` `j ``in` `range``(queries[i][``1``],` `                           ``queries[i][``2``] ``+` `1``):`   `                ``print``(arr[j], end ``=` `" "``)` `                `  `            ``print``()`   `# Driver code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``N ``=` `5` `    ``M ``=` `8` `    ``Q ``=` `5` `    ``arr ``=` `[``2``, ``2``, ``7``, ``2``, ``5``]` `    ``queries ``=` `[]` `    `  `    ``queries.append([``1``, ``0``, ``3``, ``4``])` `    ``queries.append([``1``, ``4``, ``4``, ``2``])` `    ``queries.append([``1``, ``0``, ``0``, ``7``])` `    ``queries.append([``2``, ``1``, ``3``])` `    ``queries.append([``2``, ``3``, ``3``])`   `    ``update(arr, N, M, Q, queries)` `    `  `# This code is contributed by ukasp`

## C#

 `// C# code to implement the above approach` `using` `System;` `public` `class` `GFG{`   `  ``// Function to implement the queries` `  ``public` `static` `void` `update(``int``[] arr, ``int` `N, ``int` `M, ``int` `Q, ``int``[][] queries)` `  ``{` `    ``// Loop to implement the queries` `    ``for` `(``int` `i = 0; i < Q; i++) {` `      ``if` `(queries[i] == 1) {` `        ``for` `(``int` `j = queries[i]; ` `             ``j <= queries[i];` `             ``j++)` `          ``arr[j] = (arr[j] + ` `                    ``queries[i]) % M;` `      ``}` `      ``else` `if` `(queries[i] == 2) {` `        ``for` `(``int` `j = queries[i]; ` `             ``j <= queries[i];` `             ``j++)` `          ``Console.Write(arr[j]+ ``" "``);` `        ``Console.WriteLine();` `      ``}` `    ``}` `  ``}`   `  ``// Driver's code` `  ``public` `static` `void` `Main()` `  ``{` `    ``int` `N = 5, M = 8, Q = 5;` `    ``int``[] arr = { 2, 2, 7, 2, 5 };` `    ``int``[][] queries = ``new` `int``[][] ` `    ``{` `      ``new` `int``[] { 1, 0, 3, 4 },` `      ``new` `int``[] { 1, 4, 4, 2 },` `      ``new` `int``[] { 1, 0, 0, 7 },` `      ``new` `int``[] { 2, 1, 3 },` `      ``new` `int``[] { 2, 3, 3 }` `    ``};` `    ``update(arr, N, M, Q, queries);` `  ``}` `}`   `// This code is contributed by Shubham Singh`

## Javascript

 ``

Output

```6 3 6
6 ```

Time Complexity: O(Q*N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :