# For each Array index find the maximum value among all M operations

• Last Updated : 14 Jun, 2022

Given an array arr[] of size N initially filled with 0 and another array Positions[] of size M, the task is to return the maximum value for each index after performing the following M operations:

• Make the value at index Positions[i] equal to 0
• All the numbers to the right of Positions[i] will be one greater than their immediate left neighbour.
• All the numbers to the left of Positions[i] will be one greater than their immediate right neighbour.

Examples:

Input: N = 6, M = 2, Positions = {2, 3}
Output: {3, 2, 1, 1, 2, 3}
Explanation: Initial array: {0, 0, 0, 0, 0, 0}
After first operation: {2, 1, 0, 1, 2, 3}
where each element to the right of 2nd index and each element to its left follow the given condition
After second operation:  {3, 2, 1, 0, 1, 2}
Thus, maximum value of each index among all the operations: {3, 2, 1, 1, 2, 3}

Input: N = 4, M = 3, Positions = {3, 2, 1}
Output: {3, 2, 1, 2}
Explanation: Initial array: {0, 0, 0, 0}
After first operation:  {3, 2, 1, 0}
After second operation:  {2, 1, 0, 1}
After third operation: {1, 0, 1, 2}
Thus, Maximum: {3, 2, 1, 2}

Approach: The problem can be solved based on the following observation:

The value set at the indices for each operation denotes the distance from the index set to 0.
Therefore, the positions closest to the ends of the array which are set to 0 will set the values of other indices to be the maximum when given operation is performed.

Based on the above observation, the solution is to find the indices closest to the ends of the array (say x and y) which are set to 0 at any of the operations. The maximum value for each index will be the maximum distance from any of x and y.

Follow the steps to solve the problem:

• Generate an array with null values (say arr[]).
• Find the maximum and the minimum in the Positions[] array (say x and y).
• Traverse the array from i = 0 to N-1:
• Print the maximum of the absolute difference between the current index and x or y

Below is the implementation of the above approach:

## C++

 `// C++ code for the above approach:``#include ``using` `namespace` `std;` `// Function to find the maximum values``// for each array index among M operations``vector<``int``> create(vector<``int``>& x, ``int` `n, ``int` `m)``{``    ``int` `maxa = 0;``    ``int` `mini = INT_MAX;` `    ``// Traversing the position array``    ``for` `(``int` `j = 0; j < m; j++) {``        ``maxa = max(maxa, x[j]);``        ``mini = min(mini, x[j]);``    ``}` `    ``vector<``int``> arr;` `    ``// Traversing the array``    ``for` `(``int` `k = 0; k < n; k++) {` `        ``// Print maximum of absolute``        ``// difference between maximum``        ``// and minimum positions to``        ``// current position``        ``arr.push_back(max(``abs``(k - maxa), ``abs``(k - mini)));``    ``}``    ``return` `arr;``}` `// Driver code``int` `main()``{``    ``int` `N = 4;``    ``int` `M = 3;` `    ``// Initializing a position array``    ``vector<``int``> Positions = { 3, 2, 1 };` `    ``vector<``int``> sol = create(Positions, N, M);``    ``for` `(``auto` `x : sol)``        ``cout << x << ``" "``;` `    ``return` `0;``}` `    ``// This code is contributed by rakeshsahni`

## Java

 `// Java code for the above approach:` `import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `class` `GFG {` `    ``// Function to find the maximum values``    ``// for each array index among M operations``    ``public` `static` `List create(``int` `x[],``                                       ``int` `n,``                                       ``int` `m)``    ``{``        ``int` `maxa = ``0``;``        ``int` `mini = Integer.MAX_VALUE;` `        ``// Traversing the position array``        ``for` `(``int` `j = ``0``; j < m; j++) {``            ``maxa = Math.max(maxa, x[j]);``            ``mini = Math.min(mini, x[j]);``        ``}` `        ``List arr``            ``= ``new` `ArrayList();` `        ``// Traversing the array``        ``for` `(``int` `k = ``0``; k < n; k++) {` `            ``// Print maximum of absolute``            ``// difference between maximum``            ``// and minimum positions to``            ``// current position``            ``arr.add(Math.max(``                ``Math.abs(k - maxa),``                ``Math.abs(k - mini)));``        ``}``        ``return` `arr;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `N = ``4``;``        ``int` `M = ``3``;` `        ``// Initializing a position array``        ``int` `Positions[] = { ``3``, ``2``, ``1` `};` `        ``List sol``            ``= create(Positions, N, M);``        ``for` `(``int` `x : sol)``            ``System.out.print(x + ``" "``);``    ``}``}`

## Python3

 `# Python3 code for the above approach:``import` `sys` `# Function to find the maximum values``# for each array index among M operations``def` `create(x, n, m):``    ``maxa ``=` `0``    ``mini ``=` `sys.maxsize` `    ``# Traversing the position array``    ``for` `j ``in` `range``(m):``        ``maxa ``=` `max``(maxa, x[j])``        ``mini ``=` `min``(mini, x[j])` `    ``arr ``=` `[]` `    ``# Traversing the array``    ``for` `k ``in` `range``(n):``      ` `        ``# Print maximum of absolute``        ``# difference between maximum``        ``# and minimum positions to``        ``# current position``        ``arr.append(``max``(``abs``(k ``-` `maxa), ``abs``(k ``-` `mini)))``    ``return` `arr` `# Driver Code``N ``=` `4``M ``=` `3` `# Initializing a position array``Positions ``=` `[``3``, ``2``, ``1``]``sol ``=` `create(Positions, N, M)` `print``(``" "``.join(``list``(``map``(``str``, sol))))` `# This code is contributed by Phasing17`

## C#

 `// C# code for the above approach:``using` `System;``using` `System.Collections;` `public` `class` `GFG {` `  ``// Function to find the maximum values``  ``// for each array index among M operations``  ``static` `public` `ArrayList create(``int``[] x, ``int` `n, ``int` `m)``  ``{``    ``int` `maxa = 0;``    ``int` `mini = ``int``.MaxValue;` `    ``// Traversing the position array``    ``for` `(``int` `j = 0; j < m; j++) {``      ``maxa = Math.Max(maxa, x[j]);``      ``mini = Math.Min(mini, x[j]);``    ``}` `    ``ArrayList arr = ``new` `ArrayList();` `    ``// Traversing the array``    ``for` `(``int` `k = 0; k < n; k++) {` `      ``// Print maximum of absolute``      ``// difference between maximum``      ``// and minimum positions to``      ``// current position``      ``arr.Add(Math.Max(Math.Abs(k - maxa),``                       ``Math.Abs(k - mini)));``    ``}``    ``return` `arr;``  ``}` `  ``// Driver code``  ``static` `public` `void` `Main()``  ``{` `    ``int` `N = 4;``    ``int` `M = 3;` `    ``// Initializing a position array``    ``int``[] Positions = { 3, 2, 1 };` `    ``ArrayList sol = create(Positions, N, M);``    ``for` `(``int` `i = 0; i < sol.Count; i++)``      ``Console.Write(sol[i] + ``" "``);``  ``}``}` `// This code is contributed by ninja_hattori.`

## Javascript

 ``

Output

`3 2 1 2 `

Time Complexity: O(N) + O(M), where N is the size of the array and M is the size of the position array
Auxiliary Space: O(M)

My Personal Notes arrow_drop_up