Rust Solutions for array & hashing

Author: tomijaga

rust/01_arrays_&_hashing/128_longest_consecutive_sequence.rs

@@ -0,0 +1,27 @@
+use std::{
+    collections::HashSet,
+    iter::FromIterator,
+};
+
+impl Solution {
+    pub fn longest_consecutive(nums: Vec<i32>) -> i32 {
+        let mut set : HashSet<i32> = HashSet::from_iter(nums.into_iter());
+        
+        let mut max_cnt = 0;
+        
+        for n in &set{
+            if !set.contains(&(n-1)){
+                let mut next = n + 1;
+                let mut cnt = 1;
+                while set.contains(&next){
+                    cnt +=1;
+                    next+=1;
+                }
+                
+                max_cnt = max_cnt.max(cnt);
+            }
+        }
+
+        max_cnt
+    }
+}

rust/01_arrays_&_hashing/1_two_sum.rs

@@ -0,0 +1,19 @@
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
+        let mut map = HashMap::new();
+        
+        for (i, n) in nums.into_iter().enumerate(){
+            let diff = target - n;
+            
+            if let Some(&j) = map.get(&diff){
+                return vec![i as i32, j as i32];
+            }else{
+                map.insert(n, i);
+            }
+        }
+        
+        unreachable!()
+    }
+}

rust/01_arrays_&_hashing/217_contains_duplicates.rs

@@ -0,0 +1,18 @@
+use std::collections::HashSet;
+
+impl Solution {
+    pub fn contains_duplicate(nums: Vec<i32>) -> bool {
+        let mut map = HashSet::new();
+        
+        for n in nums.iter(){
+
+            if map.contains(n){
+                return true; 
+            }
+            
+            map.insert(n);          
+        };        
+        
+        false   
+    }
+}

rust/01_arrays_&_hashing/238_product_of_array_except_self.rs

@@ -0,0 +1,18 @@
+impl Solution {
+    pub fn product_except_self(mut nums: Vec<i32>) -> Vec<i32> {
+        let mut res = vec![1; nums.len()];
+        
+        for i in (1..nums.len()){
+            res[i] = nums[i - 1] * res[i - 1];
+        }
+
+        let mut right = 1;
+
+        for (i, n) in res.iter_mut().enumerate().rev(){
+            *n = *n * right;
+            right *= nums[i];
+        }
+        
+        res
+    }
+}

rust/01_arrays_&_hashing/242_valid_anagram.rs

@@ -0,0 +1,18 @@
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn is_anagram(s: String, t: String) -> bool {
+        if (t.len() != s.len()){
+            return false;
+        }
+        
+        let mut map: HashMap<char, usize> = HashMap::new();
+        
+        for (a, b) in s.chars().zip(t.chars()){
+            *map.entry(a).or_default() +=1;
+            *map.entry(b).or_default() -=1;
+        }
+        
+        map.into_values().all(|cnt| cnt == 0)
+    }
+}

rust/01_arrays_&_hashing/271_encode_and_decode_strings.rs

@@ -0,0 +1,42 @@
+struct Codec {}
+
+impl Codec {
+    fn new() -> Self {
+        Self {}
+    }
+	
+    fn encode(&self, strs: Vec<String>) -> String {
+        let mut store = String::new();
+        
+        for s in strs{
+            let len = s.len() as u8;
+            
+            store.push(len as char);
+            store.push_str(&s);
+        }
+        
+        store
+    }
+	
+    fn decode(&self, s: String) -> Vec<String> {
+        let s: Vec<char> = s.chars().collect();
+        let mut i = 0;
+        
+        let mut res = vec![];
+        while i < s.len(){
+            let len = s[i] as u8 as usize;
+            i+=1;
+            
+            let j = i + len;
+            
+            if j <= s.len(){
+                let slice = &s[i..i + len];
+                res.push(slice.into_iter().collect::<String>());
+            }
+          
+            i+=len;
+        }
+        
+        res
+    }
+}

rust/01_arrays_&_hashing/347_top_k_frequent_elements.rs

@@ -0,0 +1,50 @@
+use std::collections::HashMap;
+use std::cmp::Ordering;
+
+impl Solution {
+    pub fn top_k_frequent(nums: Vec<i32>, k: i32) -> Vec<i32> {
+        let mut map: HashMap<i32, i32> = HashMap::new();
+        
+        for n in nums{
+            *map.entry(n).or_default() +=1;
+        }
+        
+        let mut freq: Vec<(i32, i32)> = map.into_iter().collect();
+
+        let res = if k == arr.len() as i32{
+            &freq
+        }else{
+            quick_select(&mut freq, k)
+        };
+        
+        res.into_iter()
+        .map(|&(n, _)| n)
+        .collect()
+    }
+}
+
+pub fn quick_select(slice: &mut [(i32, i32)], k: i32) -> &[(i32, i32)]{
+    let (mut pivot, mut i, mut j) = (0, 1, 1);
+    
+    for index in 1..slice.len(){
+        if slice[index].1 >= slice[pivot].1{
+            slice.swap(index, j);
+            j+=1;
+        }else{
+            slice.swap(index, i);
+            i+=1;
+            j+=1;
+        }
+    }
+    
+    slice.swap(pivot, i - 1);
+    pivot = i - 1;
+    
+    let larger_items = (j - pivot) as i32;
+    
+    match larger_items.cmp(&k) {
+        Ordering::Less => quick_select(&mut slice[0..j], k),
+        Ordering::Greater => quick_select(&mut slice[pivot + 1..j], k),
+        Ordering::Equal => &slice[pivot..j],
+    }
+}

rust/01_arrays_&_hashing/36_valid_sudoku.rs

@@ -0,0 +1,49 @@
+use std::collections::HashSet;
+
+
+impl Solution {
+    pub fn is_valid_sudoku(board: Vec<Vec<char>>) -> bool {
+        
+       let mut row: HashSet<char> = HashSet::new();
+       let mut col: HashSet<char> = HashSet::new();
+       let mut bx : HashSet<char> = HashSet::new();
+        
+        for i in 0..9{
+            for j in 0..9{
+                let r = board[i][j];
+                let c = board[j][i];
+                let b = board[i / 3 * 3 + j / 3][i/3 * 3 + j%3];
+                
+                if r != '.'{
+                    if !row.contains(&r){
+                        row.insert(r);
+                    }else{
+                        return false;
+                    }
+                }
+                
+                if c != '.'{
+                    if !col.contains(&c){
+                        col.insert(c);
+                    }else{
+                        return false;
+                    }
+                }
+                
+                if b != '.'{
+                    if !bx.contains(&b){
+                        bx.insert(b);
+                    }else{
+                        return false;
+                    }
+                }
+            }
+            
+            row.clear();
+            col.clear();
+            bx.clear();
+        }
+        
+        true
+    }
+}

rust/01_arrays_&_hashing/49_group_anagrams.rs

@@ -0,0 +1,23 @@
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn group_anagrams(strs: Vec<String>) -> Vec<Vec<String>> {
+        let mut map: HashMap<[u16; 26], Vec<String>> = HashMap::new();
+        
+        for s in strs{
+            let mut key = [0_u16; 26];
+    
+            for c in s.chars(){
+                key[c as usize - 'a' as usize] += 1;
+            }
+            
+            if let Some(vals) = map.get_mut(&key){
+                vals.push(s);
+            }else{
+                map.insert(key, vec![s]);
+            }
+        }
+        
+        map.into_values().collect::<Vec<Vec<String>>>()
+    }
+}

rust/02_two_pointers/11_container_with_most_water.rs

@@ -0,0 +1,31 @@
+impl Solution {
+    pub fn max_area(height: Vec<i32>) -> i32 {
+        let (mut l, mut r) = (0, height.len() - 1);
+        
+        let mut max = 0;
+        
+        while (l < r){
+            let (lh, rh) = (height[l], height[r]);
+            let h = lh.min(rh);
+            
+            let d = (r - l) as i32;
+            let area = d * h;
+            
+            if area > max{
+                max = area;
+            }
+            
+            if rh< lh{
+                while r > 0 && height[r] <= rh{
+                    r-=1;
+                }
+            }else{
+                while l < height.len() && height[l] <= lh{
+                    l+=1;
+                }
+            }
+        }
+        
+        max
+    }
+}