2273. Find Resultant Array After Removing Anagrams: AC

Author: tan-wei

src/solution/mod.rs

@@ -1721,3 +1721,4 @@ mod s2269_find_the_k_beauty_of_a_number;
 mod s2270_number_of_ways_to_split_array;
 mod s2271_maximum_white_tiles_covered_by_a_carpet;
 mod s2272_substring_with_largest_variance;
+mod s2273_find_resultant_array_after_removing_anagrams;

src/solution/s2273_find_resultant_array_after_removing_anagrams.rs

@@ -0,0 +1,93 @@
+/**
+ * [2273] Find Resultant Array After Removing Anagrams
+ *
+ * You are given a 0-indexed string array words, where words[i] consists of lowercase English letters.
+ * In one operation, select any index i such that 0 < i < words.length and words[i - 1] and words[i] are anagrams, and delete words[i] from words. Keep performing this operation as long as you can select an index that satisfies the conditions.
+ * Return words after performing all operations. It can be shown that selecting the indices for each operation in any arbitrary order will lead to the same result.
+ * An Anagram is a word or phrase formed by rearranging the letters of a different word or phrase using all the original letters exactly once. For example, "dacb" is an anagram of "abdc".
+ *  
+ * Example 1:
+ *
+ * Input: words = ["abba","baba","bbaa","cd","cd"]
+ * Output: ["abba","cd"]
+ * Explanation:
+ * One of the ways we can obtain the resultant array is by using the following operations:
+ * - Since words[2] = "bbaa" and words[1] = "baba" are anagrams, we choose index 2 and delete words[2].
+ *   Now words = ["abba","baba","cd","cd"].
+ * - Since words[1] = "baba" and words[0] = "abba" are anagrams, we choose index 1 and delete words[1].
+ *   Now words = ["abba","cd","cd"].
+ * - Since words[2] = "cd" and words[1] = "cd" are anagrams, we choose index 2 and delete words[2].
+ *   Now words = ["abba","cd"].
+ * We can no longer perform any operations, so ["abba","cd"] is the final answer.
+ * Example 2:
+ *
+ * Input: words = ["a","b","c","d","e"]
+ * Output: ["a","b","c","d","e"]
+ * Explanation:
+ * No two adjacent strings in words are anagrams of each other, so no operations are performed.
+ *  
+ * Constraints:
+ *
+ * 	1 <= words.length <= 100
+ * 	1 <= words[i].length <= 10
+ * 	words[i] consists of lowercase English letters.
+ *
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/
+// discuss: https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+impl Solution {
+    pub fn remove_anagrams(words: Vec<String>) -> Vec<String> {
+        let maps = words
+            .iter()
+            .map(|w| {
+                let mut lut = [0; 26];
+                for c in w.chars() {
+                    lut[c as usize - 'a' as usize] += 1;
+                }
+                lut
+            })
+            .collect::<Vec<[i32; 26]>>();
+
+        let mut result = vec![];
+
+        result.push(words[0].clone());
+
+        for i in 1..words.len() {
+            if maps[i] != maps[i - 1] {
+                result.push(words[i].clone());
+            }
+        }
+
+        result
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_2273_example_1() {
+        let words = vec_string!["abba", "baba", "bbaa", "cd", "cd"];
+
+        let result = vec_string!["abba", "cd"];
+
+        assert_eq!(Solution::remove_anagrams(words), result);
+    }
+
+    #[test]
+    fn test_2273_example_2() {
+        let words = vec_string!["a", "b", "c", "d", "e"];
+
+        let result = vec_string!["a", "b", "c", "d", "e"];
+
+        assert_eq!(Solution::remove_anagrams(words), result);
+    }
+}