Added Rust solutions for Chapter 1: Two Pointers

rust/Two Pointers/is_palindrome_valid.rs

@@ -0,0 +1,36 @@
+fn is_palindrome_valid(s: &str) -> bool {
+    // Edge case
+    if s.len() == 0 || s.len() == 1 {
+        return true;
+    }
+
+    let chars: Vec<_> = s.chars().collect();
+    let mut first_pointer = 0;
+    let mut last_pointer = s.len() - 1;
+    while first_pointer < last_pointer {
+        // Skip non-alphanumeric characters from the left. 
+        let first_char = chars[first_pointer];
+        if !first_char.is_alphanumeric() {
+            first_pointer += 1;
+            continue;
+        }
+
+        // Skip non-alphanumeric characters from the right.
+        let last_char = chars[last_pointer];
+        if !last_char.is_alphanumeric() {
+            last_pointer -= 1;
+            continue;
+        }
+
+        // If the characters at the left and right pointers don't
+        // match, the string is not a palindrome.
+        if first_char.to_ascii_lowercase() != last_char.to_ascii_lowercase() {
+            return false;
+        }
+
+        // Shrink the pointers
+        first_pointer += 1;
+        last_pointer -= 1;
+    }
+    true
+}

rust/Two Pointers/largest_container.rs

@@ -0,0 +1,34 @@
+use std::{
+    cmp::{max, min},
+    i32::MIN,
+};
+
+fn largest_container(heights: Vec<i32>) -> i32 {
+    // edge case
+    if heights.len() == 1 {
+        return 0;
+    }
+
+    let mut first_pointer = 0;
+    let mut last_pointer = heights.len() - 1;
+    let mut max_water = MIN;
+
+    while first_pointer < last_pointer {
+        // Calculate the water contained between the current pair of lines.
+        let water = min(heights[first_pointer], heights[last_pointer])
+            * (last_pointer as i32 - first_pointer as i32);
+            //  Move the pointers inward, always moving the pointer at the 
+            //  shorter line. If both lines have the same height, move both 
+            //  pointers inward.
+        max_water = max(max_water, water);
+        if heights[first_pointer] < heights[last_pointer] {
+            first_pointer += 1;
+        } else if heights[first_pointer] > heights[last_pointer] {
+            last_pointer -= 1;
+        } else {
+            first_pointer += 1;
+            last_pointer -= 1;
+        }
+    }
+    max_water
+}

rust/Two Pointers/pair_sum_sorted.rs

@@ -0,0 +1,22 @@
+fn pair_sum_sorted(nums: &[i32], target: i32) -> Vec<usize> {
+    let mut first_pointer = 0;
+    let mut last_pointer = nums.len() - 1;
+    while first_pointer < last_pointer {
+        let first_value = nums[first_pointer];
+        let last_value = nums[last_pointer];
+        let cur_sum = first_value + last_value;
+        // If the sum is smaller, increment the left pointer, aiming
+        // to increase the sum toward the target value.
+        if cur_sum < target {
+            first_pointer += 1;
+        } else if cur_sum > target {
+            // If the sum is larger, decrement the right pointer, aiming
+            // to decrease the sum toward the target value.
+            last_pointer -= 1;
+        } else {
+            // If the target pair is found, return its indexes.
+            return vec![first_pointer, last_pointer];
+        }
+    }
+    vec![]
+}

rust/Two Pointers/triplet_sum.rs

@@ -0,0 +1,46 @@
+fn triplet_sum(mut nums: Vec<i32>) -> Vec<Vec<i32>> {
+    // Sort the vector
+    nums.sort();
+    // a + b + c = 0
+    // use the pair sum sorted , b + c = -a (target);
+    let len = nums.len();
+    let mut result: Vec<Vec<i32>> = vec![];
+
+    for index in 0..len - 1 {
+        // To avoid duplicate triplets, skip 'a' if it's the same as 
+        // the previous number.
+        if index > 0 && nums[index] == nums[index - 1] {
+            continue;
+        }
+        // Find all pairs that sum to a target of '-a' (-nums[i]).
+        let triplet = pair_sum_sorted(&nums[index..], -nums[index]);
+        if triplet.len() != 0 {
+            result.push(triplet);
+        }
+    }
+
+    result
+}
+
+fn pair_sum_sorted(remain_nums: &[i32], target: i32) -> Vec<i32> {
+    let mut first_pointer = 0;
+    let mut last_pointer = remain_nums.len() - 1;
+
+    while first_pointer < last_pointer {
+        let sum = remain_nums[first_pointer] + remain_nums[last_pointer];
+        // If sum is equal to target return the  triplet [a,b,c]
+        if sum == target {
+            return vec![
+                -target,
+                remain_nums[first_pointer],
+                remain_nums[last_pointer],
+            ];
+        } else if sum < target {
+            first_pointer += 1;
+        } else {
+            last_pointer -= 1;
+        }
+    }
+    // If there is no triplet return empty vector
+    vec![]
+}