Solve 12/75

.gitignore

···
 /target
+src/playground

.zed/debug.json

···
+// Project-local debug tasks
+//
+// For more documentation on how to configure debug tasks,
+// see: https://zed.dev/docs/debugger
+[]

README.md

···
 
 ### Blind 75
 
-- [ ] Contains Duplicate   	
-- [ ] Valid Anagram   	
-- [ ] Two Sum   	
-- [ ] Group Anagrams   	
-- [ ] Top K Frequent Elements   	
-- [ ] Encode and Decode Strings   	
-- [ ] Product of Array Except Self   	
-- [ ] Longest Consecutive Sequence   	
-- [ ] Valid Palindrome  
-- [x] 3 Sum [[#15]](https://leetcode.com/problems/3sum/) src/two_pointers/three_sum.rs
-- [x] Container With Most Water [[#11]](https://leetcode.com/problems/container-with-most-water/) src/two_pointers/max_area.rs
-- [x] Best Time to Buy and Sell Stock [[#121]](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/) src/sliding_window/max_profit.rs
+#### Array & Hashing
+
+- [ ] Contains Duplicate
+      [[#217]](https://leetcode.com/problems/contains-duplicate/)
+- [x] Valid Anagram
+      [[#242]](https://leetcode.com/problems/valid-anagram/)
+      src/array_hashing/is_anagram.rs
+- [x] Two Sum
+      [[#1]](https://leetcode.com/problems/two-sum/)
+      src/array_hashing/two_sum.rs
+- [ ] Group Anagrams
+      [[#49]](https://leetcode.com/problems/group-anagrams/)
+- [ ] Top K Frequent Elements
+      [[#347]](https://leetcode.com/problems/top-k-frequent-elements/)
+- [ ] Encode and Decode Strings
+      [[#271]](https://leetcode.com/problems/encode-and-decode-strings/)
+- [ ] Product of Array Except Self
+      [[#238]](https://leetcode.com/problems/product-of-array-except-self/)
+- [ ] Longest Consecutive Sequence
+      [[#128]](https://leetcode.com/problems/longest-consecutive-sequence/)
+
+#### Two Pointers
+
+- [x] Valid Palindrome
+      [[#125]](https://leetcode.com/problems/valid-palindrome/)
+      src/two_pointers/is_palindrome.rs
+- [x] 3 Sum
+      [[#15]](https://leetcode.com/problems/3sum/)
+      src/two_pointers/three_sum.rs
+- [x] Container With Most Water
+      [[#11]](https://leetcode.com/problems/container-with-most-water/)
+      src/two_pointers/max_area.rs
+
+#### Sliding Window
+
+- [x] Best Time to Buy and Sell Stock
+      [[#121]](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/)
+      src/sliding_window/max_profit.rs
+- [x] Longest Substring Without Repeating Characters 
+      [[#3]](https://leetcode.com/problems/longest-substring-without-repeating-characters/)
+      src/sliding_window/length_of_longest_substring.rs
+- [x] Longest Repeating Character Replacement
+      [[#424]](https://leetcode.com/problems/longest-repeating-character-replacement/)
+      src/sliding_window/character_replacement.rs
+- [x] Minimum Window Substring
+      [[#76]](https://leetcode.com/problems/minimum-window-substring/)
+      src/sliding_window/min_window.rs
+      
+
+#### Stack
+
+- [x] Valid Parentheses
+      [[#20]](https://leetcode.com/problems/valid-parentheses/)
+      src/stack/is_valid_parentheses.rs
+      
+#### Binary Search
+
+- [x] Find Minimum In Rotated Sorted Array
+      [[#153]](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/)
+      src/binary_search/find_min.rs
+- [x] Search In Rotated Sorted Array
+      [[#33]](https://leetcode.com/problems/search-in-rotated-sorted-array/)
+      src/binary_search/search.rs
+
+#### Linked List 
 
-- [ ] Longest Substring Without Repeating Characters   	
-- [ ] Longest Repeating Character Replacement   	
-- [ ] Minimum Window Substring   	
-- [ ] Valid Parentheses   	
-- [ ] Find Minimum In Rotated Sorted Array   	
-- [ ] Search In Rotated Sorted Array   	
-- [ ] Reverse Linked List   	
-- [ ] Merge Two Sorted Lists   	
-- [ ] Linked List Cycle   	
-- [ ] Reorder List   	
-- [ ] Remove Nth Node From End of List   	
-- [ ] Merge K Sorted Lists   	
-- [ ] Invert Binary Tree   	
-- [ ] Maximum Depth of Binary Tree   	
-- [ ] Same Tree   	
-- [ ] Subtree of Another Tree   	
-- [ ] Lowest Common Ancestor of a Binary Search Tree   	
-- [ ] Binary Tree Level Order Traversal   	
-- [ ] Validate Binary Search Tree   	
-- [ ] Kth Smallest Element In a Bst   	
-- [ ] Construct Binary Tree From Preorder And Inorder Traversal   	
-- [ ] Binary Tree Maximum Path Sum   	
-- [ ] Serialize And Deserialize Binary Tree   	
-- [ ] Find Median From Data Stream   	
-- [ ] Combination Sum   	
-- [ ] Word Search   	
-- [ ] Implement Trie Prefix Tree   	
-- [ ] Design Add And Search Words Data Structure   	
-- [ ] Word Search II   	
-- [ ] Number of Islands   	
-- [ ] Clone Graph   	
-- [ ] Pacific Atlantic Water Flow   	
-- [ ] Course Schedule   	
-- [ ] Graph Valid Tree   	
-- [ ] Number of Connected Components In An Undirected Graph   	
-- [ ] Alien Dictionary   	
-- [ ] Climbing Stairs   	
-- [ ] House Robber   	
-- [ ] House Robber II   	
-- [ ] Longest Palindromic Substring   	
-- [ ] Palindromic Substrings   	
-- [ ] Decode Ways   	
-- [ ] Coin Change   	
-- [ ] Maximum Product Subarray   	
-- [ ] Word Break   	
-- [ ] Longest Increasing Subsequence   	
-- [ ] Unique Paths   	
-- [ ] Longest Common Subsequence   	
-- [ ] Maximum Subarray   	
-- [ ] Jump Game   	
-- [ ] Insert Interval   	
-- [ ] Merge Intervals   	
-- [ ] Non Overlapping Intervals   	
-- [ ] Meeting Rooms   	
-- [ ] Meeting Rooms II   	
-- [ ] Rotate Image   	
-- [ ] Spiral Matrix   	
-- [ ] Set Matrix Zeroes   	
-- [ ] Number of 1 Bits   	
-- [ ] Counting Bits   	
-- [ ] Reverse Bits   	
-- [ ] Missing Number   	
+- [ ] Reverse Linked List
+      [[#206]](https://leetcode.com/problems/reverse-linked-list/) 
+      src/linked_list/reverse_list.rs
+- [ ] Merge Two Sorted Lists 
+      [[#21]](https://leetcode.com/problems/merge-two-sorted-lists/)
+      src/linked_list/merge_two_lists.rs
+- [ ] Linked List Cycle
+      [[#141]](https://leetcode.com/problems/linked-list-cycle/)
+- [ ] Reorder List
+      [[#143]](https://leetcode.com/problems/reorder-list/)
+- [ ] Remove Nth Node From End of List
+      [[#19]](https://leetcode.com/problems/remove-nth-node-from-end-of-list/)
+- [ ] Merge K Sorted Lists
+      [[#23]](https://leetcode.com/problems/merge-k-sorted-lists/)
+
+#### Trees
+
+- [ ] Invert Binary Tree
+      [[#226]](https://leetcode.com/problems/invert-binary-tree/)
+- [ ] Maximum Depth of Binary Tree
+      [[#104]](https://leetcode.com/problems/maximum-depth-of-binary-tree/)
+- [ ] Same Tree
+      [[#100]](https://leetcode.com/problems/same-tree/)
+- [ ] Subtree of Another Tree
+      [[#572]](https://leetcode.com/problems/subtree-of-another-tree/)
+- [ ] Lowest Common Ancestor of a Binary Search Tree
+      [[#235]](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/)
+- [ ] Binary Tree Level Order Traversal
+      [[#102]](https://leetcode.com/problems/binary-tree-level-order-traversal/)
+- [ ] Validate Binary Search Tree
+      [[#98]](https://leetcode.com/problems/validate-binary-search-tree/)
+- [ ] Kth Smallest Element In a Bst
+      [[#230]](https://leetcode.com/problems/kth-smallest-element-in-a-bst/)
+- [ ] Construct Binary Tree From Preorder And Inorder Traversal
+      [[#105]](https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/)
+- [ ] Binary Tree Maximum Path Sum
+      [[#124]](https://leetcode.com/problems/binary-tree-maximum-path-sum/)
+- [ ] Serialize And Deserialize Binary Tree
+      [[#297]](https://leetcode.com/problems/serialize-and-deserialize-binary-tree/)
+
+#### Heap / Priority Queue
+
+- [ ] Find Median From Data Stream
+      [[#295]](https://leetcode.com/problems/find-median-from-data-stream/)
+
+#### Backtracking
+
+- [ ] Combination Sum
+      [[#39]](https://leetcode.com/problems/combination-sum/)
+- [ ] Word Search
+      [[#79]](https://leetcode.com/problems/word-search/)
+
+#### Tries
+
+- [ ] Implement Trie Prefix Tree
+      [[#208]](https://leetcode.com/problems/implement-trie-prefix-tree/)
+- [ ] Design Add And Search Words Data Structure
+      [[#211]](https://leetcode.com/problems/design-add-and-search-words-data-structure/)
+- [ ] Word Search II
+      [[#212]](https://leetcode.com/problems/word-search-ii/)
+
+#### Graphs
+
+- [ ] Number of Islands
+      [[#200]](https://leetcode.com/problems/number-of-islands/)
+- [ ] Clone Graph
+      [[#133]](https://leetcode.com/problems/clone-graph/)
+- [ ] Pacific Atlantic Water Flow
+      [[#417]](https://leetcode.com/problems/pacific-atlantic-water-flow/)
+- [ ] Course Schedule
+      [[#207]](https://leetcode.com/problems/course-schedule/)
+- [ ] Graph Valid Tree
+      [[#261]](https://leetcode.com/problems/graph-valid-tree/)
+- [ ] Number of Connected Components In An Undirected Graph
+      [[#323]](https://leetcode.com/problems/number-of-connected-components-in-an-undirected-graph/)
+
+#### Advanced Graphs
+
+- [ ] Alien Dictionary
+      [[#269]](https://leetcode.com/problems/alien-dictionary/)
+
+#### 1-D Dynamic Programming
+
+- [ ] Climbing Stairs
+      [[#70]](https://leetcode.com/problems/climbing-stairs/)
+- [ ] House Robber
+      [[#198]](https://leetcode.com/problems/house-robber/)
+- [ ] House Robber II
+      [[#213]](https://leetcode.com/problems/house-robber-ii/)
+- [ ] Longest Palindromic Substring
+      [[#5]](https://leetcode.com/problems/longest-palindromic-substring/)
+- [ ] Palindromic Substrings
+      [[#647]](https://leetcode.com/problems/palindromic-substrings/)
+- [ ] Decode Ways
+      [[#91]](https://leetcode.com/problems/decode-ways/)
+- [ ] Coin Change
+      [[#322]](https://leetcode.com/problems/coin-change/)
+- [ ] Maximum Product Subarray
+      [[#152]](https://leetcode.com/problems/maximum-product-subarray/)
+- [ ] Word Break
+      [[#139]](https://leetcode.com/problems/word-break/)
+- [ ] Longest Increasing Subsequence
+      [[#300]](https://leetcode.com/problems/longest-increasing-subsequence/)
+
+#### 2-D Dynamic Programming
+
+- [ ] Unique Paths
+      [[#62]](https://leetcode.com/problems/unique-paths/)
+- [ ] Longest Common Subsequence
+      [[#1143]](https://leetcode.com/problems/longest-common-subsequence/)
+
+#### Greedy
+
+- [ ] Maximum Subarray
+      [[#53]](https://leetcode.com/problems/maximum-subarray/)
+- [ ] Jump Game
+      [[#55]](https://leetcode.com/problems/jump-game/)
+
+#### Intervals
+
+- [ ] Insert Interval
+      [[#57]](https://leetcode.com/problems/insert-interval/)
+- [ ] Merge Intervals
+      [[#56]](https://leetcode.com/problems/merge-intervals/)
+- [ ] Non Overlapping Intervals
+      [[#435]](https://leetcode.com/problems/non-overlapping-intervals/)
+- [ ] Meeting Rooms
+      [[#252]](https://leetcode.com/problems/meeting-rooms/)
+- [ ] Meeting Rooms II
+      [[#253]](https://leetcode.com/problems/meeting-rooms-ii/)
+
+#### Math & Geometry
+
+- [ ] Rotate Image
+      [[#48]](https://leetcode.com/problems/rotate-image/)
+- [ ] Spiral Matrix
+      [[#54]](https://leetcode.com/problems/spiral-matrix/)
+- [ ] Set Matrix Zeroes
+      [[#73]](https://leetcode.com/problems/set-matrix-zeroes/)
+
+#### Bit Manipulation
+
+- [ ] Number of 1 Bits
+      [[#191]](https://leetcode.com/problems/number-of-1-bits/)
+- [ ] Counting Bits
+      [[#338]](https://leetcode.com/problems/counting-bits/)
+- [ ] Reverse Bits
+      [[#190]](https://leetcode.com/problems/reverse-bits/)
+- [ ] Missing Number
+      [[#268]](https://leetcode.com/problems/missing-number/)
 - [ ] Sum of Two Integers
+      [[#371]](https://leetcode.com/problems/sum-of-two-integers/)

src/array_hashing/is_anagram.rs

···
+use std::collections::HashMap;
+
+pub fn is_anagram(s: String, t: String) -> bool {
+    let mut hash = HashMap::new();
+
+    for char in s.chars() {
+        let entry = hash.entry(char).or_insert(0);
+        *entry += 1;
+    }
+
+    for char in t.chars() {
+        let entry = hash.entry(char).or_insert(0);
+        *entry -= 1;
+    }
+
+    for a in hash.into_values() {
+        if a != 0 {
+            return false;
+        }
+    }
+
+    true
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::array_hashing::is_anagram::is_anagram;
+
+    #[test]
+    fn case_1() {
+        assert_eq!(is_anagram("anagram".into(), "nagaram".into()), true);
+        assert_eq!(is_anagram("rat".into(), "car".into()), false);
+    }
+}

src/array_hashing/mod.rs

···
+pub mod is_anagram;
+pub mod two_sum;

src/array_hashing/two_sum.rs

···
+use std::collections::HashMap;
+
+pub fn two_sum(numbers: Vec<i32>, target: i32) -> Vec<i32> {
+    let mut mp: HashMap<&i32, usize> = HashMap::new();
+    for (index, num) in numbers.iter().enumerate() {
+        if let Some(match_index) = mp.get(&(target - num)) {
+            return vec![*match_index as i32 + 1_i32, index.clone() as i32 + 1];
+        }
+        mp.insert(num, index);
+    }
+    return vec![];
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::array_hashing::two_sum::two_sum;
+
+    #[test]
+    fn case_1() {
+        assert_eq!(two_sum(vec![2, 7, 11, 15], 9,), vec![1, 2]);
+        assert_eq!(two_sum(vec![2, 3, 4], 6,), vec![1, 3]);
+    }
+}

src/binary_search/find_min.rs

···
+pub fn find_min(nums: Vec<i32>) -> i32 {
+    if nums.len() == 0 {
+        return -1;
+    }
+    let mut low = 0 as usize;
+    let mut high = nums.len() - 1;
+    let mut min = nums[low];
+    while high >= low {
+        if nums[low] < nums[high] {
+            min = nums[low].min(min);
+            break;
+        }
+        let mid = (high + low) / 2;
+        min = nums[mid].min(min);
+        if nums[mid] >= nums[low] {
+            low = mid + 1
+        } else {
+            high = mid - 1
+        }
+    }
+    min
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::binary_search::find_min::find_min;
+
+    #[test]
+    fn case_1() {
+        // rotated 3 times
+        assert_eq!(find_min(vec![3, 4, 5, 1, 2]), 1);
+        // rotated 4 times
+        assert_eq!(find_min(vec![4, 5, 6, 7, 0, 1, 2]), 0);
+        // rotated 4 times
+        assert_eq!(find_min(vec![11, 13, 15, 17]), 11);
+    }
+}

src/binary_search/mod.rs

···
+pub mod find_min;
+pub mod search;

src/binary_search/search.rs

···
+pub fn search(nums: Vec<i32>, target: i32) -> i32 {
+    let mut low = 0;
+    let mut high = nums.len() - 1;
+    while low <= high {
+        let mid = (low + high) / 2;
+        if nums[mid] == target {
+            return mid as i32;
+        }
+        if nums[mid] >= nums[low] {
+            if target > nums[mid] || target < nums[low] {
+                low = mid + 1;
+            } else {
+                high = mid - 1;
+            }
+        } else {
+            if target < nums[mid] || target > nums[high] {
+                high = mid - 1;
+            } else {
+                low = mid + 1;
+            }
+        }
+    }
+    -1
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::binary_search::search::search;
+
+    #[test]
+    fn case_1() {
+        // rotated 3 times
+        assert_eq!(search(vec![4, 5, 6, 7, 0, 1, 2], 0), 4);
+        // rotated 4 times
+        assert_eq!(search(vec![4, 5, 6, 7, 0, 1, 2], 3), -1);
+        // rotated 4 times
+        assert_eq!(search(vec![1], 0), -1);
+    }
+}

src/lib.rs

···
+pub mod array_hashing;
+pub mod binary_search;
 pub mod sliding_window;
+pub mod stack;
 pub mod two_pointers;

src/sliding_window/character_replacement.rs

···
+// Hash Table, String, Sliding Window
+use std::collections::HashMap;
+
+pub fn character_replacement(s: String, k: i32) -> i32 {
+    let mut count = HashMap::new();
+    let mut res = 0;
+    let mut left = 0;
+    let mut maxf = 0;
+    let chars: Vec<char> = s.chars().collect();
+    for right in 0..chars.len() {
+        let entry = count.entry(chars[right]).or_insert(0);
+        *entry += 1;
+        maxf = maxf.max(*entry);
+        while (right - left + 1) - maxf > k as usize {
+            let entry = count.entry(chars[left]).or_insert(0);
+            *entry -= 1;
+            left += 1;
+        }
+        res = res.max(right - left + 1);
+    }
+
+    return res as i32;
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::sliding_window::character_replacement::character_replacement;
+
+    #[test]
+    fn case_1() {
+        assert_eq!(character_replacement("XYYX".into(), 2), 4);
+        assert_eq!(character_replacement("AAABABB".into(), 1), 5);
+        assert_eq!(character_replacement("AABABBA".into(), 1), 4);
+    }
+}

src/sliding_window/length_of_longest_substring.rs

···
+use std::collections::HashMap;
+
+pub fn length_of_longest_substring(s: String) -> i32 {
+    let mut hash = HashMap::new();
+    let mut longest = 0;
+    let mut low = -1;
+    for (high, char) in s.chars().enumerate() {
+        if let Some(i) = hash.insert(char, high as i32) {
+            low = low.max(i);
+        }
+        longest = longest.max(high as i32 - low);
+    }
+    longest
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::sliding_window::length_of_longest_substring::length_of_longest_substring;
+
+    #[test]
+    fn case_1() {
+        assert_eq!(length_of_longest_substring("xz2qasze".into()), 6);
+    }
+}

src/sliding_window/min_window.rs

···
+// use std::collections::HashMap;
+
+fn hash(c: char) -> usize {
+    let c = c as u8;
+    if c >= b'a' {
+        (c - b'a') as usize
+    } else {
+        (c - b'A' + 26) as usize
+    }
+}
+
+pub fn min_window(s: String, t: String) -> String {
+    // first try
+    // if t.is_empty() {
+    //     return String::new();
+    // }
+    // let mut counts = HashMap::new();
+    // let mut window = HashMap::new();
+    // let s_chars: Vec<char> = s.chars().collect();
+    // for c in t.chars() {
+    //     *counts.entry(c).or_insert(0) += 1
+    // }
+
+    // let need = counts.len();
+    // let mut have = 0;
+    // let mut res = (-1_isize, -1_isize);
+    // let mut res_len = f32::MAX;
+    // let mut l = 0;
+    // for r in 0..s.len() {
+    //     let right_c = s_chars[r];
+    //     *window.entry(right_c).or_insert(0) += 1;
+    //     if counts.contains_key(&right_c) && window[&right_c] == counts[&right_c] {
+    //         have += 1;
+    //     }
+    //     while have == need {
+    //         let len = (r - l) as f32 + 1_f32;
+    //         if len < res_len {
+    //             res = (l as isize, r as isize);
+    //             res_len = len;
+    //         }
+    //         let left_c = s_chars[l];
+    //         *window.entry(left_c).or_insert(0) -= 1;
+    //         if counts.contains_key(&left_c) && window[&left_c] < counts[&left_c] {
+    //             have -= 1
+    //         }
+    //         l += 1
+    //     }
+    // }
+    // let (l, r) = res;
+    // if res_len != f32::MAX {
+    //     s[l as usize..=r as usize].to_string()
+    // } else {
+    //     String::new()
+    // }
+
+    // cheat
+    let s_vec: Vec<usize> = s.chars().map(|c| hash(c)).collect();
+    let mut counts = t
+        .chars()
+        .map(|c| hash(c))
+        .fold(vec![0i32; 52usize], |mut acc, c| {
+            acc[c] += 1;
+            acc
+        });
+    let mut unique = counts.iter().filter(|x| **x > 0).count();
+
+    let mut bounds = (0, 0);
+    let mut min_len = s.len() + 1;
+    let mut back = 0;
+
+    for (front, &c) in s_vec.iter().enumerate() {
+        counts[c] -= 1;
+
+        if counts[c] == 0 {
+            unique -= 1;
+        }
+
+        while unique == 0 {
+            if min_len > front - back {
+                bounds = (back, front + 1);
+                min_len = front - back;
+            }
+
+            counts[s_vec[back]] += 1;
+
+            if counts[s_vec[back]] > 0 {
+                unique += 1;
+            }
+
+            back += 1;
+        }
+    }
+
+    s[bounds.0..bounds.1].to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::sliding_window::min_window::min_window;
+    #[test]
+    fn case_1() {
+        assert_eq!(
+            min_window("OUZODYXAZV".into(), "XYZ".into()),
+            "YXAZ".to_string()
+        );
+    }
+}

src/sliding_window/mod.rs

···
+pub mod character_replacement;
+pub mod length_of_longest_substring;
 pub mod max_profit;
+pub mod min_window;

src/stack/is_valid_parentheses.rs

···
+pub fn is_valid_parentheses(s: String) -> bool {
+    let mut stack = vec![];
+    for char in s.chars() {
+        match char {
+            '{' => {
+                stack.push('{');
+            }
+            '[' => {
+                stack.push('[');
+            }
+            '(' => {
+                stack.push('(');
+            }
+            ')' => {
+                if let Some('(') = stack.pop() {
+                } else {
+                    return false;
+                }
+            }
+            ']' => {
+                if let Some('[') = stack.pop() {
+                } else {
+                    return false;
+                }
+            }
+            '}' => {
+                if let Some('{') = stack.pop() {
+                } else {
+                    return false;
+                }
+            }
+            _ => {}
+        }
+    }
+    stack.len() == 0
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::stack::is_valid_parentheses::is_valid_parentheses;
+
+    #[test]
+    fn case_1() {
+        assert_eq!(is_valid_parentheses("[]".into()), true);
+        assert_eq!(is_valid_parentheses("([{}])".into()), true);
+        assert_eq!(is_valid_parentheses("[(])".into()), false);
+        assert_eq!(is_valid_parentheses("])".into()), false);
+    }
+}

src/stack/mod.rs

···
+pub mod is_valid_parentheses;

src/two_pointers/is_palindrome.rs

···
+pub fn is_palindrome(s: String) -> bool {
+    let mut low = 0 as usize;
+    let mut high = s.len() - 1;
+    let chars: Vec<char> = s.chars().collect();
+    while high > low {
+        if !chars[high].is_alphanumeric() {
+            high -= 1;
+            continue;
+        }
+        if !chars[low].is_alphanumeric() {
+            low += 1;
+            continue;
+        }
+
+        if chars[high].to_ascii_lowercase() != chars[low].to_ascii_lowercase() {
+            return false;
+        }
+        high -= 1;
+        low += 1;
+    }
+    return true;
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::two_pointers::is_palindrome::is_palindrome;
+
+    #[test]
+    fn case_1() {
+        assert_eq!(is_palindrome("Was it a car or a cat I saw?".into()), true);
+        assert_eq!(is_palindrome("race a car".into()), false);
+    }
+}

src/two_pointers/mod.rs

···
+pub mod is_palindrome;
 pub mod max_area;
 pub mod three_sum;