Merge pull request #10 from rickrain/rickrain/prob-11-water-container

Rickrain/prob 11 water container

Author: rickrain

README.md

@@ -16,6 +16,7 @@ Each challenge in this repo is organized into a module with tests specific to th
 - [string to int](./src/prob_0008_string_to_int/README.md)
 - [palindrome](./src/prob_0009_palindrome/README.md)
 - [permutations](./src/prob_0046_permutations/README.md)
+- [container w/most water](./src/prob_0011_container_with_most_water/README.md)
 
 ## Running the challenges
 

src/main.rs

@@ -7,6 +7,7 @@ mod prob_0006_zigzag_conversation;
 mod prob_0007_reverse_integer;
 mod prob_0008_string_to_int;
 mod prob_0009_palindrome;
+mod prob_0011_container_with_most_water;
 mod prob_0046_permutations;
 
 fn main() {}

src/prob_0004_median_two_sorted_arrays/mod.rs

@@ -28,12 +28,20 @@ impl Solution {
                 let mid2 = ((nums1.len() + nums2.len() + 1) / 2) - mid1;
 
                 // Get the values on either side of the partition for the smaller array
-                let l1 = if mid1 == 0           { i32::MIN } else { nums1[mid1 - 1] };
-                let r1 = if mid1 >= nums1.len() { i32::MAX } else { nums1[mid1]     };
+                let l1 = if mid1 == 0 { i32::MIN } else { nums1[mid1 - 1] };
+                let r1 = if mid1 >= nums1.len() {
+                    i32::MAX
+                } else {
+                    nums1[mid1]
+                };
 
                 // Get the values on either side of the partition for the larger array
-                let l2 = if mid2 == 0           { i32::MIN } else { nums2[mid2 - 1] };
-                let r2 = if mid2 >= nums2.len() { i32::MAX } else { nums2[mid2]     };
+                let l2 = if mid2 == 0 { i32::MIN } else { nums2[mid2 - 1] };
+                let r2 = if mid2 >= nums2.len() {
+                    i32::MAX
+                } else {
+                    nums2[mid2]
+                };
 
                 // We're done partitioning the array and can calculate the median
                 if l1 <= r2 && l2 <= r1 {

src/prob_0011_container_with_most_water/11_ex_01.jpg

@@ -0,0 +1,36 @@
+# Container With Most Water
+
+[Back to root-level README](../../README.md)
+
+You are given an integer array `height` of length `n`. There are `n` vertical lines drawn such that the two endpoints of the i<sup>th</sup> line are `(i, 0)` and `(i, height[i])`.
+
+Find two lines that together with the x-axis form a container, such that the container contains the most water.
+
+Return _the maximum amount of water a container can store_.
+
+**Notice** that you may not slant the container.
+
+## Examples
+
+### Example 1
+
+![Example 1](./11_ex_01.jpg)
+
+```console
+Input: height = [1,8,6,2,5,4,8,3,7]
+Output: 49
+Explanation: The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In this case, the max area of water (blue section) the container can contain is 49.
+```
+
+### Example 2
+
+```console
+Input: height = [1,1]
+Output: 1
+```
+
+## Constraints
+
+- `n == height.length`
+- `2 <= n <= 10^5`
+- `0 <= height[i] <= 10^4`

src/prob_0011_container_with_most_water/README.md

@@ -0,0 +1,36 @@
+use std::cmp;
+
+pub struct Solution;
+
+#[allow(dead_code)]
+impl Solution {
+    pub fn max_area(height: Vec<i32>) -> i32 {
+        let mut left_idx = 0;
+        let mut right_idx = height.len() - 1;
+        let mut max_area = 0;
+
+        while left_idx < right_idx {
+            let gap = (right_idx - left_idx) as i32;
+            max_area = max_area.max(cmp::min(height[left_idx], height[right_idx]) * gap);
+
+            if height[left_idx] < height[right_idx] {
+                left_idx += 1;
+            } else {
+                right_idx -= 1;
+            }
+        }
+
+        max_area
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::prob_0011_container_with_most_water::Solution;
+
+    #[test]
+    fn solution_works() {
+        assert_eq!(Solution::max_area(vec![1, 8, 6, 2, 5, 4, 8, 3, 7]), 49);
+        assert_eq!(Solution::max_area(vec![1, 1]), 1);
+    }
+}