# Trapping Rain Water

Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it is able to trap after raining.

Examples:

```Input: arr[]   = {2, 0, 2}
Output: 2
Structure is like below
| |
|_|
We can trap 2 units of water in the middle gap.

Input: arr[]   = {3, 0, 0, 2, 0, 4}
Output: 10
Structure is like below
|
|    |
|  | |
|__|_|
We can trap "3*2 units" of water between 3 an 2,
"1 unit" on top of bar 2 and "3 units" between 2
and 4.  See below diagram also.

Input: arr[] = [0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1]
Output: 6
|
|   || |
_|_||_||||||
Trap "1 unit" between first 1 and 2, "4 units" between
first 2 and 3 and "1 unit" between second last 1 and last 2 ``` ## We strongly recommend that you click here and practice it, before moving on to the solution.

An element of the array can store water if there are higher bars on left and right. We can find the amount of water to be stored in every element by finding the heights of bars on left and right sides. The idea is to compute the amount of water that can be stored in every element of array. For example, consider the array {3, 0, 0, 2, 0, 4}, we can store three units of water at indexes 1 and 2, and one unit of water at index 3, and three units of water at index 4.

A Simple Solution is to traverse every array element and find the highest bars on left and right sides. Take the smaller of two heights. The difference between the smaller height and height of the current element is the amount of water that can be stored in this array element. Time complexity of this solution is O(n2).

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include  ` `using` `namespace` `std;  ` ` `  `// Function to return the maximum ` `// water that can be stored ` `int` `maxWater(``int` `arr[], ``int` `n)  ` `{ ` `     `  `    ``// To store the maximum water  ` `    ``// that can be stored ` `    ``int` `res = 0; ` `     `  `    ``// For every element of the array ` `    ``for` `(``int` `i = 1; i < n-1; i++) { ` `         `  `        ``// Find the maximum element on its left ` `        ``int` `left = arr[i]; ` `        ``for` `(``int` `j=0; j

## Python3

 `# Python3 implementation of the approach  ` ` `  `# Function to return the maximum  ` `# water that can be stored  ` `def` `maxWater(arr, n) : ` `     `  `    ``# To store the maximum water  ` `    ``# that can be stored  ` `    ``res ``=` `0``;  ` `     `  `    ``# For every element of the array  ` `    ``for` `i ``in` `range``(``1``, n ``-` `1``) :  ` `         `  `        ``# Find the maximum element on its left  ` `        ``left ``=` `arr[i];  ` `        ``for` `j ``in` `range``(i) : ` `            ``left ``=` `max``(left, arr[j]);  ` `         `  `        ``# Find the maximum element on its right  ` `        ``right ``=` `arr[i];  ` `         `  `        ``for` `j ``in` `range``(i ``+` `1` `, n) :  ` `            ``right ``=` `max``(right, arr[j]); ` `             `  `        ``# Update the maximum water ` `        ``res ``=` `res ``+` `(``min``(left, right) ``-` `arr[i]);  ` ` `  `    ``return` `res;  ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `:  ` ` `  `    ``arr ``=` `[``0``, ``1``, ``0``, ``2``, ``1``, ``0``,  ` `           ``1``, ``3``, ``2``, ``1``, ``2``, ``1``];  ` `    ``n ``=` `len``(arr);  ` `     `  `    ``print``(maxWater(arr, n));  ` `     `  `# This code is contributed by AnkitRai01 `

Output:

```6
```

An Efficient Solution is to pre-compute highest bar on left and right of every bar in O(n) time. Then use these pre-computed values to find the amount of water in every array element.

Below is the implementation of this solution.

## C++

 `// C++ program to find maximum amount of water that can ` `// be trapped within given set of bars. ` `#include ` `using` `namespace` `std; ` ` `  `int` `findWater(``int` `arr[], ``int` `n) ` `{ ` `    ``// left[i] contains height of tallest bar to the ` `    ``// left of i'th bar including itself ` `    ``int` `left[n]; ` ` `  `    ``// Right [i] contains height of tallest bar to ` `    ``// the right of ith bar including itself ` `    ``int` `right[n]; ` ` `  `    ``// Initialize result ` `    ``int` `water = 0; ` ` `  `    ``// Fill left array ` `    ``left = arr; ` `    ``for` `(``int` `i = 1; i < n; i++) ` `        ``left[i] = max(left[i - 1], arr[i]); ` ` `  `    ``// Fill right array ` `    ``right[n - 1] = arr[n - 1]; ` `    ``for` `(``int` `i = n - 2; i >= 0; i--) ` `        ``right[i] = max(right[i + 1], arr[i]); ` ` `  `    ``// Calculate the accumulated water element by element ` `    ``// consider the amount of water on i'th bar, the ` `    ``// amount of water accumulated on this particular ` `    ``// bar will be equal to min(left[i], right[i]) - arr[i] . ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``water += min(left[i], right[i]) - arr[i]; ` ` `  `    ``return` `water; ` `} ` ` `  `// Driver program ` `int` `main() ` `{ ` `    ``int` `arr[] = { 0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``cout << ``"Maximum water that can be accumulated is "` `         ``<< findWater(arr, n); ` `    ``return` `0; ` `}`

## Java

 `// Java program to find maximum amount of water that can ` `// be trapped within given set of bars. ` ` `  `class` `Test { ` `    ``static` `int` `arr[] = ``new` `int``[] { ``0``, ``1``, ``0``, ``2``, ``1``, ``0``, ``1``, ``3``, ``2``, ``1``, ``2``, ``1` `}; ` ` `  `    ``// Method for maximum amount of water ` `    ``static` `int` `findWater(``int` `n) ` `    ``{ ` `        ``// left[i] contains height of tallest bar to the ` `        ``// left of i'th bar including itself ` `        ``int` `left[] = ``new` `int``[n]; ` ` `  `        ``// Right [i] contains height of tallest bar to ` `        ``// the right of ith bar including itself ` `        ``int` `right[] = ``new` `int``[n]; ` ` `  `        ``// Initialize result ` `        ``int` `water = ``0``; ` ` `  `        ``// Fill left array ` `        ``left[``0``] = arr[``0``]; ` `        ``for` `(``int` `i = ``1``; i < n; i++) ` `            ``left[i] = Math.max(left[i - ``1``], arr[i]); ` ` `  `        ``// Fill right array ` `        ``right[n - ``1``] = arr[n - ``1``]; ` `        ``for` `(``int` `i = n - ``2``; i >= ``0``; i--) ` `            ``right[i] = Math.max(right[i + ``1``], arr[i]); ` ` `  `        ``// Calculate the accumulated water element by element ` `        ``// consider the amount of water on i'th bar, the ` `        ``// amount of water accumulated on this particular ` `        ``// bar will be equal to min(left[i], right[i]) - arr[i] . ` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `            ``water += Math.min(left[i], right[i]) - arr[i]; ` ` `  `        ``return` `water; ` `    ``} ` ` `  `    ``// Driver method to test the above function ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` ` `  `        ``System.out.println(``"Maximum water that can be accumulated is "` `+ findWater(arr.length)); ` `    ``} ` `} `

## Python3

 `# Python program to find maximum amount of water that can ` `# be trapped within given set of bars. ` ` `  `def` `findWater(arr, n): ` ` `  `    ``# left[i] contains height of tallest bar to the ` `    ``# left of i'th bar including itself ` `    ``left ``=` `[``0``]``*``n ` ` `  `    ``# Right [i] contains height of tallest bar to ` `    ``# the right of ith bar including itself ` `    ``right ``=` `[``0``]``*``n ` ` `  `    ``# Initialize result ` `    ``water ``=` `0` ` `  `    ``# Fill left array ` `    ``left[``0``] ``=` `arr[``0``] ` `    ``for` `i ``in` `range``( ``1``, n): ` `        ``left[i] ``=` `max``(left[i``-``1``], arr[i]) ` ` `  `    ``# Fill right array ` `    ``right[n``-``1``] ``=` `arr[n``-``1``] ` `    ``for` `i ``in` `range``(n``-``2``, ``-``1``, ``-``1``): ` `        ``right[i] ``=` `max``(right[i ``+` `1``], arr[i]); ` ` `  `    ``# Calculate the accumulated water element by element ` `    ``# consider the amount of water on i'th bar, the ` `    ``# amount of water accumulated on this particular ` `    ``# bar will be equal to min(left[i], right[i]) - arr[i] . ` `    ``for` `i ``in` `range``(``0``, n): ` `        ``water ``+``=` `min``(left[i], right[i]) ``-` `arr[i] ` ` `  `    ``return` `water ` ` `  ` `  `# Driver program ` ` `  `arr ``=` `[``0``, ``1``, ``0``, ``2``, ``1``, ``0``, ``1``, ``3``, ``2``, ``1``, ``2``, ``1``] ` `n ``=` `len``(arr) ` `print``(``"Maximum water that can be accumulated is"``, findWater(arr, n)) ` ` `  `# This code is contributed by ` `# Smitha Dinesh Semwal `

## C#

 `// C# program to find maximum amount of water that can ` `// be trapped within given set of bars. ` `using` `System; ` ` `  `class` `Test { ` `    ``static` `int``[] arr = ``new` `int``[] { 0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1 }; ` ` `  `    ``// Method for maximum amount of water ` `    ``static` `int` `findWater(``int` `n) ` `    ``{ ` `        ``// left[i] contains height of tallest bar to the ` `        ``// left of i'th bar including itself ` `        ``int``[] left = ``new` `int``[n]; ` ` `  `        ``// Right [i] contains height of tallest bar to ` `        ``// the right of ith bar including itself ` `        ``int``[] right = ``new` `int``[n]; ` ` `  `        ``// Initialize result ` `        ``int` `water = 0; ` ` `  `        ``// Fill left array ` `        ``left = arr; ` `        ``for` `(``int` `i = 1; i < n; i++) ` `            ``left[i] = Math.Max(left[i - 1], arr[i]); ` ` `  `        ``// Fill right array ` `        ``right[n - 1] = arr[n - 1]; ` `        ``for` `(``int` `i = n - 2; i >= 0; i--) ` `            ``right[i] = Math.Max(right[i + 1], arr[i]); ` ` `  `        ``// Calculate the accumulated water element by element ` `        ``// consider the amount of water on i'th bar, the ` `        ``// amount of water accumulated on this particular ` `        ``// bar will be equal to min(left[i], right[i]) - arr[i] . ` `        ``for` `(``int` `i = 0; i < n; i++) ` `            ``water += Math.Min(left[i], right[i]) - arr[i]; ` ` `  `        ``return` `water; ` `    ``} ` ` `  `    ``// Driver method to test the above function ` `    ``public` `static` `void` `Main() ` `    ``{ ` ` `  `        ``Console.WriteLine(``"Maximum water that can be accumulated is "` `+ findWater(arr.Length)); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m. `

## PHP

 `= 0; ``\$i``--) ` `    ``\$right``[``\$i``] = max(``\$right``[``\$i` `+ 1],  ` `                           ``\$arr``[``\$i``]); ` ` `  `    ``// Calculate the accumulated ` `    ``// water element by element ` `    ``// consider the amount of  ` `    ``// water on i'th bar, the ` `    ``// amount of water accumulated ` `    ``// on this particular ` `    ``// bar will be equal to min(left[i],  ` `    ``// right[i]) - arr[i] . ` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++) ` `    ``\$water` `+= min(``\$left``[``\$i``], ``\$right``[``\$i``])  ` `                             ``- ``\$arr``[``\$i``]; ` ` `  `    ``return` `\$water``; ` `} ` ` `  `    ``// Driver program ` `    ``\$arr` `= ``array``(0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1); ` `    ``\$n` `= sizeof(``\$arr``); ` `    ``echo` `"Maximum water that can be accumulated is "``, ` `        ``findWater(``\$arr``, ``\$n``); ` `     `  `// This code is contributed by ajit ` `?> `

Output:

`Maximum water that can be accumulated is 6`

Time Complexity: O(n)
Auxiliary Space: O(n)

Space Optimization in above solution: Instead of maintaing two arrays of size n for storing left and right max of each element, we will just maintain two variables to store the maximum till that point. Since water trapped at any element = min( max_left, max_right) – arr[i] we will calculate water trapped on smaller element out of A[lo] and A[hi] first and move the pointers till lo doesn’t cross hi.

Below is the implementation of the above approach:

## C++

 `// C++ program to find maximum amount of water that can ` `// be trapped within given set of bars. ` `// Space Complexity : O(1) ` ` `  `#include ` `using` `namespace` `std; ` ` `  `int` `findWater(``int` `arr[], ``int` `n) ` `{ ` `    ``// initialize output ` `    ``int` `result = 0; ` ` `  `    ``// maximum element on left and right ` `    ``int` `left_max = 0, right_max = 0; ` ` `  `    ``// indices to traverse the array ` `    ``int` `lo = 0, hi = n - 1; ` ` `  `    ``while` `(lo <= hi) { ` `        ``if` `(arr[lo] < arr[hi]) { ` `            ``if` `(arr[lo] > left_max) ` `                ``// update max in left ` `                ``left_max = arr[lo]; ` `            ``else` `                ``// water on curr element = max - curr ` `                ``result += left_max - arr[lo]; ` `            ``lo++; ` `        ``} ` `        ``else` `{ ` `            ``if` `(arr[hi] > right_max) ` `                ``// update right maximum ` `                ``right_max = arr[hi]; ` `            ``else` `                ``result += right_max - arr[hi]; ` `            ``hi--; ` `        ``} ` `    ``} ` ` `  `    ``return` `result; ` `} ` ` `  `int` `main() ` `{ ` `    ``int` `arr[] = { 0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``cout << ``"Maximum water that can be accumulated is "` `         ``<< findWater(arr, n); ` `} ` ` `  `// This code is contributed by Aditi Sharma `

## Java

 `// JAVA Code For Trapping Rain Water ` `import` `java.util.*; ` ` `  `class` `GFG { ` ` `  `    ``static` `int` `findWater(``int` `arr[], ``int` `n) ` `    ``{ ` `        ``// initialize output ` `        ``int` `result = ``0``; ` ` `  `        ``// maximum element on left and right ` `        ``int` `left_max = ``0``, right_max = ``0``; ` ` `  `        ``// indices to traverse the array ` `        ``int` `lo = ``0``, hi = n - ``1``; ` ` `  `        ``while` `(lo <= hi) { ` `            ``if` `(arr[lo] < arr[hi]) { ` `                ``if` `(arr[lo] > left_max) ` ` `  `                    ``// update max in left ` `                    ``left_max = arr[lo]; ` `                ``else` ` `  `                    ``// water on curr element = ` `                    ``// max - curr ` `                    ``result += left_max - arr[lo]; ` `                ``lo++; ` `            ``} ` `            ``else` `{ ` `                ``if` `(arr[hi] > right_max) ` ` `  `                    ``// update right maximum ` `                    ``right_max = arr[hi]; ` ` `  `                ``else` `                    ``result += right_max - arr[hi]; ` `                ``hi--; ` `            ``} ` `        ``} ` ` `  `        ``return` `result; ` `    ``} ` ` `  `    ``/* Driver program to test above function */` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `arr[] = { ``0``, ``1``, ``0``, ``2``, ``1``, ``0``, ``1``, ` `                      ``3``, ``2``, ``1``, ``2``, ``1` `}; ` `        ``int` `n = arr.length; ` ` `  `        ``System.out.println(``"Maximum water that "` `                           ``+ ``"can be accumulated is "` `                           ``+ findWater(arr, n)); ` `    ``} ` `} ` `// This code is contributed by Arnav Kr. Mandal. `

## Python3

 `# Python program to find ` `# maximum amount of water that can ` `# be trapped within given set of bars. ` `# Space Complexity : O(1) ` ` `  `def` `findWater(arr, n): ` ` `  `    ``# initialize output ` `    ``result ``=` `0` `      `  `    ``# maximum element on left and right ` `    ``left_max ``=` `0` `    ``right_max ``=` `0` `      `  `    ``# indices to traverse the array ` `    ``lo ``=` `0` `    ``hi ``=` `n``-``1` `      `  `    ``while``(lo <``=` `hi):  ` `     `  `        ``if``(arr[lo] < arr[hi]): ` `         `  `            ``if``(arr[lo] > left_max): ` ` `  `                ``# update max in left ` `                ``left_max ``=` `arr[lo] ` `            ``else``: ` ` `  `                ``# water on curr element = max - curr ` `                ``result ``+``=` `left_max ``-` `arr[lo] ` `            ``lo``+``=` `1` `         `  `        ``else``: ` `         `  `            ``if``(arr[hi] > right_max): ` `                ``# update right maximum ` `                ``right_max ``=` `arr[hi] ` `            ``else``: ` `                ``result ``+``=` `right_max ``-` `arr[hi] ` `            ``hi``-``=` `1` `         `  `    ``return` `result ` `  `  `# Driver program ` ` `  `arr ``=` `[``0``, ``1``, ``0``, ``2``, ``1``, ``0``, ``1``, ``3``, ``2``, ``1``, ``2``, ``1``] ` `n ``=` `len``(arr) ` ` `  `print``(``"Maximum water that can be accumulated is "``, ` `        ``findWater(arr, n)) ` ` `  `# This code is contributed ` `# by Anant Agarwal. `

## C#

 `// C# Code For Trapping Rain Water ` `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``static` `int` `findWater(``int``[] arr, ``int` `n) ` `    ``{ ` `        ``// initialize output ` `        ``int` `result = 0; ` ` `  `        ``// maximum element on left and right ` `        ``int` `left_max = 0, right_max = 0; ` ` `  `        ``// indices to traverse the array ` `        ``int` `lo = 0, hi = n - 1; ` ` `  `        ``while` `(lo <= hi) { ` `            ``if` `(arr[lo] < arr[hi]) { ` `                ``if` `(arr[lo] > left_max) ` ` `  `                    ``// update max in left ` `                    ``left_max = arr[lo]; ` `                ``else` ` `  `                    ``// water on curr element = ` `                    ``// max - curr ` `                    ``result += left_max - arr[lo]; ` `                ``lo++; ` `            ``} ` `            ``else` `{ ` `                ``if` `(arr[hi] > right_max) ` ` `  `                    ``// update right maximum ` `                    ``right_max = arr[hi]; ` ` `  `                ``else` `                    ``result += right_max - arr[hi]; ` `                ``hi--; ` `            ``} ` `        ``} ` ` `  `        ``return` `result; ` `    ``} ` ` `  `    ``// Driver program ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int``[] arr = { 0, 1, 0, 2, 1, 0, 1, ` `                      ``3, 2, 1, 2, 1 }; ` `        ``int` `result = Trap.findWater(arr, arr.length); ` `        ``System.``out``.print(``" Total trapping water: "` `+ result); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m. `

## PHP

 ` ``\$left_max``) ` `             `  `                ``// update max in left ` `                ``\$left_max` `= ``\$arr``[``\$lo``]; ` `             `  `            ``else` `             `  `                ``// water on curr  ` `                ``// element = max - curr ` `                ``\$result` `+= ``\$left_max` `- ``\$arr``[``\$lo``]; ` `                ``\$lo``++; ` `        ``} ` `        ``else` `        ``{ ` `            ``if``(``\$arr``[``\$hi``] > ``\$right_max``) ` `             `  `                ``// update right maximum ` `                ``\$right_max` `= ``\$arr``[``\$hi``]; ` `            ``else` `                ``\$result` `+= ``\$right_max` `- ``\$arr``[``\$hi``]; ` `                ``\$hi``--; ` `        ``} ` `    ``} ` `     `  `    ``return` `\$result``; ` `} ` ` `  `    ``// Driver Code ` `    ``\$arr` `= ``array``(0, 1, 0, 2, 1, 0,  ` `                 ``1, 3, 2, 1, 2, 1); ` `    ``\$n` `= ``count``(``\$arr``); ` `    ``echo` `"Maximum water that can be accumulated is "``, findWater(``\$arr``, ``\$n``);  ` ` `  `// This code is contributed by anuj_67. ` `?> `

Output:

```Maximum water that can be accumulated is 6
```

Time Complexity: O(n)
Auxiliary Space: O(1)

Thanks to Gaurav Ahirwar and Aditi Sharma for above solution.

Here is another approach for O(n) time and O(1) space complexity.

• Loop from index 0 to the end of the given array.
• If a wall greater than or equal to the previous wall is encountered then make note of the index of that wall in a var called prev_index.
• Keep adding previous wall’s height minus the current (ith) wall to the variable water.
• Have a temporary variable that stores the same value as water.
• If no wall greater than or equal to the previous wall is found then quit.
• If prev_index < size of the input array then subtract the temp variable from water, and loop from end of the input array to prev_index and find a wall greater than or equal to the previous wall (in this case, the last wall from backwards).

The concept here is that if there is a larger wall to the right then the water can be retained with height equal to the smaller wall on the left. If there are no larger walls to the right then start from the left. There must be a larger wall to the left now.

Below is the implementation of the above approach:

## Java

 `// Java implementation of the approach ` `class` `GFG { ` ` `  `    ``// Function to return the maximum ` `    ``// water that can be stored ` `    ``public` `static` `int` `maxWater(``int` `arr[], ``int` `n) ` `    ``{ ` `        ``int` `size = n - ``1``; ` ` `  `        ``// Let the first element be stored as ` `        ``// previous, we shall loop from index 1 ` `        ``int` `prev = arr[``0``]; ` ` `  `        ``// To store previous wall's index ` `        ``int` `prev_index = ``0``; ` `        ``int` `water = ``0``; ` ` `  `        ``// To store the water until a larger wall ` `        ``// is found, if there are no larger walls ` `        ``// then delete temp value from water ` `        ``int` `temp = ``0``; ` `        ``for` `(``int` `i = ``1``; i <= size; i++) { ` ` `  `            ``// If the current wall is taller than ` `            ``// the previous wall then make current ` `            ``// wall as the previous wall and its ` `            ``// index as previous wall's index ` `            ``// for the subsequent loops ` `            ``if` `(arr[i] >= prev) { ` `                ``prev = arr[i]; ` `                ``prev_index = i; ` ` `  `                ``// Because larger or same height wall is found ` `                ``temp = ``0``; ` `            ``} ` `            ``else` `{ ` ` `  `                ``// Since current wall is shorter than ` `                ``// the previous, we subtract previous ` `                ``// wall's height from the current wall's ` `                ``// height and add it to the water ` `                ``water += prev - arr[i]; ` ` `  `                ``// Store the same value in temp as well ` `                ``// If we dont find any larger wall then ` `                ``// we will subtract temp from water ` `                ``temp += prev - arr[i]; ` `            ``} ` `        ``} ` ` `  `        ``// If the last wall was larger than or equal ` `        ``// to the previous wall then prev_index would ` `        ``// be equal to size of the array (last element) ` `        ``// If we didn't find a wall greater than or equal ` `        ``// to the previous wall from the left then ` `        ``// prev_index must be less than the index ` `        ``// of the last element ` `        ``if` `(prev_index < size) { ` ` `  `            ``// Temp would've stored the water collected ` `            ``// from previous largest wall till the end ` `            ``// of array if no larger wall was found then ` `            ``// it has excess water and remove that ` `            ``// from 'water' var ` `            ``water -= temp; ` ` `  `            ``// We start from the end of the array, so previous ` `            ``// should be assigned to the last element ` `            ``prev = arr[size]; ` ` `  `            ``// Loop from the end of array up to the 'previous index' ` `            ``// which would contain the "largest wall from the left" ` `            ``for` `(``int` `i = size; i >= prev_index; i--) { ` ` `  `                ``// Right end wall will be definitely smaller ` `                ``// than the 'previous index' wall ` `                ``if` `(arr[i] >= prev) { ` `                    ``prev = arr[i]; ` `                ``} ` `                ``else` `{ ` `                    ``water += prev - arr[i]; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// Return the maximum water ` `        ``return` `water; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `arr[] = { ``0``, ``1``, ``0``, ``2``, ``1``, ``0``, ``1``, ``3``, ``2``, ``1``, ``2``, ``1` `}; ` `        ``int` `n = arr.length; ` `        ``System.out.print(maxWater(arr, n)); ` `    ``} ` `} `

## Python3

 `# Pythpn3 implementation of the approach ` ` `  `# Function to return the maximum ` `# water that can be stored ` `def` `maxWater(arr, n): ` `    ``size ``=` `n ``-` `1` ` `  `    ``# Let the first element be stored as ` `    ``# previous, we shall loop from index 1 ` `    ``prev ``=` `arr[``0``] ` ` `  `    ``# To store previous wall's index ` `    ``prev_index ``=` `0` `    ``water ``=` `0` ` `  `    ``# To store the water until a larger wall ` `    ``# is found, if there are no larger walls ` `    ``# then delete temp value from water ` `    ``temp ``=` `0` `    ``for` `i ``in` `range``(``1``, size ``+` `1``): ` ` `  `        ``# If the current wall is taller than ` `        ``# the previous wall then make current ` `        ``# wall as the previous wall and its ` `        ``# index as previous wall's index ` `        ``# for the subsequent loops ` `        ``if` `(arr[i] >``=` `prev): ` `            ``prev ``=` `arr[i] ` `            ``prev_index ``=` `i ` ` `  `            ``# Because larger or same height wall is found ` `            ``temp ``=` `0` `        ``else``: ` ` `  `            ``# Since current wall is shorter than ` `            ``# the previous, we subtract previous ` `            ``# wall's height from the current wall's ` `            ``# height and add it to the water ` `            ``water ``+``=` `prev ``-` `arr[i] ` ` `  `            ``# Store the same value in temp as well ` `            ``# If we dont find any larger wall then ` `            ``# we will subtract temp from water ` `            ``temp ``+``=` `prev ``-` `arr[i] ` ` `  `    ``# If the last wall was larger than or equal ` `    ``# to the previous wall then prev_index would ` `    ``# be equal to size of the array (last element) ` `    ``# If we didn't find a wall greater than or equal ` `    ``# to the previous wall from the left then ` `    ``# prev_index must be less than the index ` `    ``# of the last element ` `    ``if` `(prev_index < size): ` ` `  `        ``# Temp would've stored the water collected ` `        ``# from previous largest wall till the end ` `        ``# of array if no larger wall was found then ` `        ``# it has excess water and remove that ` `        ``# from 'water' var ` `        ``water ``-``=` `temp ` ` `  `        ``# We start from the end of the array, so previous ` `        ``# should be assigned to the last element ` `        ``prev ``=` `arr[size] ` ` `  `        ``# Loop from the end of array up to the 'previous index' ` `        ``# which would contain the "largest wall from the left" ` `        ``for` `i ``in` `range``(size, prev_index ``-` `1``, ``-``1``): ` ` `  `            ``# Right end wall will be definitely smaller ` `            ``# than the 'previous index' wall ` `            ``if` `(arr[i] >``=` `prev): ` `                ``prev ``=` `arr[i] ` `            ``else``: ` `                ``water ``+``=` `prev ``-` `arr[i] ` ` `  `    ``# Return the maximum water ` `    ``return` `water ` ` `  `# Driver code ` `arr ``=` `[``0``, ``1``, ``0``, ``2``, ``1``, ``0``, ``1``, ``3``, ``2``, ``1``, ``2``, ``1``] ` `n ``=` `len``(arr) ` `print``(maxWater(arr, n)) ` ` `  `# This code is contributed by Mohit Kumar `

Output:

```6
```

Time Complexity: O(n)
Auxiliary Space: O(1)