add 890

Author: fishercoder1534

README.md

@@ -57,6 +57,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |900|[RLE Iterator](https://leetcode.com/problems/rle-iterator/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_900.java) | O(n) | O(1) | |Medium|
 |897|[Increasing Order Search Tree](https://leetcode.com/problems/increasing-order-search-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_897.java) | O(n) | O(n) | |Easy| DFS, recursion
 |896|[Monotonic Array](https://leetcode.com/problems/monotonic-array/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_896.java) | O(n) | O(1) | |Easy|
+|890|[Find and Replace Pattern](https://leetcode.com/problems/find-and-replace-pattern/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_890.java) | O(n) | O(1) | |Medium|
 |884|[Uncommon Words from Two Sentences](https://leetcode.com/problems/uncommon-words-from-two-sentences/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_884.java) | O(n) | O(k) | |Easy|
 |876|[Middle of the Linked List](https://leetcode.com/problems/middle-of-the-linked-list/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_876.java) | O(n) | O(1) | |Easy|
 |872|[Leaf-Similar Trees](https://leetcode.com/problems/leaf-similar-trees/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_872.java) | O(n) | O(h) | |Easy| DFS, recursion

src/main/java/com/fishercoder/solutions/_890.java

@@ -0,0 +1,59 @@
+package com.fishercoder.solutions;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * 890. Find and Replace Pattern
+ *
+ * You have a list of words and a pattern, and you want to know which words in words matches the pattern.
+ * A word matches the pattern if there exists a permutation of letters p so that after replacing every letter x in the pattern with p(x), we get the desired word.
+ * (Recall that a permutation of letters is a bijection from letters to letters: every letter maps to another letter, and no two letters map to the same letter.)
+ * Return a list of the words in words that match the given pattern.
+ * You may return the answer in any order.
+ *
+ *  Example 1:
+ *
+ * Input: words = ["abc","deq","mee","aqq","dkd","ccc"], pattern = "abb"
+ * Output: ["mee","aqq"]
+ * Explanation: "mee" matches the pattern because there is a permutation {a -> m, b -> e, ...}.
+ * "ccc" does not match the pattern because {a -> c, b -> c, ...} is not a permutation,
+ * since a and b map to the same letter.
+ *
+ * Note:
+ * 1 <= words.length <= 50
+ * 1 <= pattern.length = words[i].length <= 20
+ */
+public class _890 {
+  public static class Solution1 {
+    public List<String> findAndReplacePattern(String[] words, String pattern) {
+      List<String> result = new ArrayList<>();
+      for (String word : words) {
+        Map<Character, Character> map = new HashMap<>();
+        Set<Character> set = new HashSet<>();
+        boolean match = true;
+        for (int i = 0; i < pattern.length(); i++) {
+          if (map.containsKey(pattern.charAt(i))) {
+            if (word.charAt(i) != map.get(pattern.charAt(i))) {
+              match = false;
+              break;
+            }
+          } else {
+            map.put(pattern.charAt(i), word.charAt(i));
+            if (!set.add(word.charAt(i))) {
+              match = false;
+            }
+          }
+        }
+        if (match) {
+          result.add(word);
+        }
+      }
+      return result;
+    }
+  }
+}

src/test/java/com/fishercoder/_890Test.java

@@ -0,0 +1,24 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._890;
+import java.util.Arrays;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _890Test {
+  private static _890.Solution1 solution1;
+
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _890.Solution1();
+  }
+
+  @Test
+  public void test1() {
+    assertEquals(Arrays.asList("mee", "aqq"),
+        solution1.findAndReplacePattern(new String[] {"abc", "deq", "mee", "aqq", "dkd", "ccc"},
+            "abb"));
+  }
+}