8-7-2020

Author: safrannn

src/_0049_group_anagrams.rs

@@ -0,0 +1,31 @@
+struct Solution;
+
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn group_anagrams(strs: Vec<String>) -> Vec<Vec<String>> {
+        let mut h_map: HashMap<Vec<char>, Vec<String>> = HashMap::new();
+        for str in strs {
+            let mut str_: Vec<char> = str.chars().collect();
+            str_.sort();
+            let h_group = h_map.entry(str_).or_insert(Vec::new());
+            (*h_group).push(str);
+        }
+
+        let mut result: Vec<Vec<String>> = h_map.into_iter().map(|(_k, v)| v).collect();
+        result.sort_by_key(|x| x.len());
+        result
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::group_anagrams(vec_string!["eat", "tea", "tan", "ate", "nat", "bat"]),
+        vec![
+            vec_string!["bat"],
+            vec_string!["tan", "nat"],
+            vec_string!["eat", "tea", "ate"],
+        ]
+    );
+}

src/_1239_maximum_length_of_a_concatenated_string_with_unique_characters.rs

@@ -0,0 +1,49 @@
+struct Solution;
+
+impl Solution {
+    pub fn max_length(arr: Vec<String>) -> i32 {
+        let arr: Vec<u32> = arr
+            .into_iter()
+            .filter_map(|s| {
+                let mut word_bit: u32 = 0;
+                for b in s.bytes() {
+                    let b_: u32 = 1 << (b - b'a');
+                    if b_ & word_bit != 0 {
+                        return None;
+                    } else {
+                        word_bit |= b_;
+                    }
+                }
+                Some(word_bit)
+            })
+            .collect();
+
+        let mut result: u32 = 0;
+        Self::dfs(&arr, 0, &mut result, 0);
+        result as i32
+    }
+
+    fn dfs(arr: &Vec<u32>, index: usize, maximum: &mut u32, current_concat: u32) {
+        if index == arr.len() {
+            *maximum = (*maximum).max(current_concat.count_ones());
+        } else {
+            if arr[index] & current_concat == 0 {
+                Self::dfs(arr, index + 1, maximum, current_concat | arr[index]);
+            }
+            Self::dfs(arr, index + 1, maximum, current_concat);
+        }
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(Solution::max_length(vec_string!["un", "iq", "ue"]), 4);
+    assert_eq!(
+        Solution::max_length(vec_string!["cha", "r", "act", "ers"]),
+        6
+    );
+    assert_eq!(
+        Solution::max_length(vec_string!["abcdefghijklmnopqrstuvwxyz"]),
+        26
+    );
+}

src/lib.rs

@@ -44,6 +44,8 @@ mod _0038_count_and_say;
 //
 mod _0046_permutations;
 //
+mod _0049_group_anagrams;
+//
 mod _0053_maximum_subarray;
 //
 mod _0056_merge_intervals;
@@ -184,6 +186,8 @@ mod _1021_remove_outermost_parentheses;
 //
 mod _1029_two_city_scheduling;
 //
+mod _1239_maximum_length_of_a_concatenated_string_with_unique_characters;
+//
 mod _1249_minimum_remove_to_make_valid_parentheses;
 //
 mod _1281_subtract_the_product_and_sum_of_digits_of_an_integer;