add 953

fishercoder1534 · fishercoder1534 · commit 0bd5f1288df6 · 2019-01-01T18:47:32.000-08:00
diff --git a/README.md b/README.md
@@ -31,6 +31,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |-----|----------------|---------------|---------------|---------------|--------|-------------|-------------
 |965|[Univalued Binary Tree](https://leetcode.com/problems/univalued-binary-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_965.java) | O(n) | O(h) | |Easy| DFS, recursion
 |961|[N-Repeated Element in Size 2N Array](https://leetcode.com/problems/n-repeated-element-in-size-2n-array/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_961.java) | O(n) | O(1) | |Easy|
+|953|[Verifying an Alien Dictionary](https://leetcode.com/problems/verifying-an-alien-dictionary/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_953.java) | O(1) | O(1) | |Easy|
 |944|[Delete Columns to Make Sorted](https://leetcode.com/problems/delete-columns-to-make-sorted/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_944.java) | O(n) | O(1) | |Easy|
 |941|[Valid Mountain Array](https://leetcode.com/problems/valid-mountain-array/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_941.java) | O(n) | O(1) | |Easy|
 |933|[Number of Recent Calls](https://leetcode.com/problems/number-of-recent-calls/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_933.java) | O(n) | O(n) | |Easy|
diff --git a/src/main/java/com/fishercoder/solutions/_953.java b/src/main/java/com/fishercoder/solutions/_953.java
@@ -0,0 +1,75 @@
+package com.fishercoder.solutions;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 953. Verifying an Alien Dictionary
+ *
+ * In an alien language, surprisingly they also use english lowercase letters, but possibly in a different order. The order of the alphabet is some permutation of lowercase letters.
+ *
+ * Given a sequence of words written in the alien language, and the order of the alphabet, return true if and only if the given words are sorted lexicographicaly in this alien language.
+ *
+ * Example 1:
+ *
+ * Input: words = ["hello","leetcode"], order = "hlabcdefgijkmnopqrstuvwxyz"
+ * Output: true
+ * Explanation: As 'h' comes before 'l' in this language, then the sequence is sorted.
+ *
+ * Example 2:
+ *
+ * Input: words = ["word","world","row"], order = "worldabcefghijkmnpqstuvxyz"
+ * Output: false
+ * Explanation: As 'd' comes after 'l' in this language, then words[0] > words[1], hence the sequence is unsorted.
+ *
+ * Example 3:
+ *
+ * Input: words = ["apple","app"], order = "abcdefghijklmnopqrstuvwxyz"
+ * Output: false
+ * Explanation: The first three characters "app" match, and the second string is shorter (in size.) According to lexicographical rules "apple" > "app", because 'l' > '∅', where '∅' is defined as the blank character which is less than any other character (More info).
+ *
+ *
+ * Note:
+ * 1 <= words.length <= 100
+ * 1 <= words[i].length <= 20
+ * order.length == 26
+ * All characters in words[i] and order are english lowercase letters.
+ */
+public class _953 {
+  public static class Solution1 {
+    public boolean isAlienSorted(String[] words, String order) {
+      if (words.length == 1) {
+        return true;
+      }
+
+      Map<Character, Integer> map = new HashMap<>();
+      for (int i = 0; i < order.length(); i++) {
+        map.put(order.charAt(i), i);
+      }
+
+      for (int i = 0; i < words.length - 1; i++) {
+        String firstWord = words[i];
+        String secondWord = words[i + 1];
+        if (!sorted(firstWord, secondWord, map)) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    private boolean sorted(String firstWord, String secondWord, Map<Character, Integer> map) {
+      for (int i = 0; i < Math.min(firstWord.length(), secondWord.length()); i++) {
+        if (firstWord.charAt(i) == secondWord.charAt(i)) {
+          continue;
+        } else {
+          if (map.get(firstWord.charAt(i)) > map.get(secondWord.charAt(i))) {
+            return false;
+          } else {
+            return true;
+          }
+        }
+      }
+      return firstWord.length() <= secondWord.length();
+    }
+  }
+}
diff --git a/src/test/java/com/fishercoder/_953Test.java b/src/test/java/com/fishercoder/_953Test.java
@@ -0,0 +1,39 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._953;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _953Test {
+  private static _953.Solution1 solution1;
+  private static String[] words;
+  private static String order;
+
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _953.Solution1();
+  }
+
+  @Test
+  public void test1() {
+    words = new String[] {"hello", "leetcode"};
+    order = "hlabcdefgijkmnopqrstuvwxyz";
+    assertEquals(true, solution1.isAlienSorted(words, order));
+  }
+
+  @Test
+  public void test2() {
+    words = new String[] {"word", "world", "row"};
+    order = "worldabcefghijkmnpqstuvxyz";
+    assertEquals(false, solution1.isAlienSorted(words, order));
+  }
+
+  @Test
+  public void test3() {
+    words = new String[] {"apple", "app"};
+    order = "abcdefghijklmnopqrstuvwxyz";
+    assertEquals(false, solution1.isAlienSorted(words, order));
+  }
+}
