953_Verifying_an_Alien_Dictionary and 954_Array_of_Doubled_Pairs

Author: qiyuangong

README.md

@@ -184,6 +184,8 @@ Also, there are open source implementations for basic data structs and algorithm
 | 929 | [Unique Email Addresses](https://leetcode.com/problems/unique-email-addresses/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/929_Unique_Email_Addresses.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/929_Unique_Email_Addresses.java) | String handle and hash (or set) |
 | 945 | [Minimum Increment to Make Array Unique](https://leetcode.com/problems/minimum-increment-to-make-array-unique/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/945_Minimum_Increment_to_Make_Array_Unique.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/945_Minimum_Increment_to_Make_Array_Unique.java) | Sort, then list duplicate and missing value in sorted list. O(nlgn) and O(n) |
 | 946 | [Validate Stack Sequences](https://leetcode.com/problems/validate-stack-sequences/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/946_Validate_Stack_Sequences.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/946_Validate_Stack_Sequences.java) | Add a stack named inStack to help going through pushed and popped. O(n) and O(n) |
+| 953 | [Verifying an Alien Dictionary](https://leetcode.com/contest/weekly-contest-114/problems/verifying-an-alien-dictionary/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/953_Verifying_an_Alien_Dictionary.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/953_Verifying_an_Alien_Dictionary.java) | Use hashmap to store index of each value, then create a comparator based on this index, O(n) and O(n) |
+| 954 | [Array of Doubled Pairs](https://leetcode.com/contest/weekly-contest-114/problems/array-of-doubled-pairs/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/954_Array_of_Doubled_Pairs.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/954_Array_of_Doubled_Pairs.java) | Sort, then use hashmap to store the frequency of each value. Then, check n, 2 * n in hashmap, O(nlogn) and O(n) |
 
 | # | To Understand |
 |---| ----- |

java/179_Largest_Number.java

@@ -29,7 +29,6 @@ public String largestNumber(int[] nums) {
         for (String numAsStr : asStrs) {
             largestNumberStr += numAsStr;
         }
-
         return largestNumberStr;
     }
 }

java/905_Sort_Array_By_Parity.java

@@ -1,6 +1,10 @@
 class Solution {
-    /*public int[] sortArrayByParity(int[] A) {
-        Array.sort(A, (a, b)-> Integer.compare(a%2, b%2));
+/*    public int[] sortArrayByParity(int[] A) {
+        A = Arrays.stream(A).
+                boxed().
+                sorted((a, b) -> Integer.compare(a% 2, b % 2)).
+                mapToInt(i -> i).
+                toArray();
         return A;
     }*/
 

java/953_Verifying_an_Alien_Dictionary.java

@@ -0,0 +1,25 @@
+class Solution {
+    HashMap<Character, Integer> orderMap = new HashMap<>();
+    public boolean isAlienSorted(String[] words, String order) {
+        // Put value index map into hashmap
+        for (int i = 0; i < order.length(); i++) {
+            orderMap.put(order.charAt(i), i);
+        }
+        for (int i = 0; i < words.length - 1; i++) {
+            if (cmp_alien(words[i], words[i + 1]) > 0) return false; 
+        }
+        return true;
+        
+    }
+    private int cmp_alien(String a, String b) {
+        int ls = a.length() < b.length() ? a.length(): b.length();
+        int pos = 0;
+        // Compare based on hashmap
+        while (pos < ls) {
+            if (orderMap.get(a.charAt(pos)) != orderMap.get(b.charAt(pos)))
+                return orderMap.get(a.charAt(pos)) - orderMap.get(b.charAt(pos));
+            pos += 1;
+        }
+        return a.length() <= b.length() ? -1: 1;
+    }
+}

java/954_Array_of_Doubled_Pairs.java

@@ -0,0 +1,24 @@
+class Solution {
+    public boolean canReorderDoubled(int[] A) {
+        HashMap<Integer, Integer> valueMap = new HashMap<>();
+        // Sort in[] with comparator
+        A = Arrays.stream(A).
+                boxed().
+                sorted((a, b) -> Integer.compare(Math.abs(a), Math.abs(b))).
+                mapToInt(i -> i).
+                toArray();
+        for (int n: A) valueMap.put(n, valueMap.getOrDefault(n, 0) + 1);
+        for (int n: A) {
+            if (valueMap.get(n) <= 0) continue;
+            if (valueMap.containsKey(2 * n) && valueMap.get(2 * n) > 0) {
+                valueMap.put(n, valueMap.get(n) - 1);
+                valueMap.put(2 * n, valueMap.get(2 * n) - 1);
+            } else {
+                return false;
+            }
+        }
+        return true;
+    }
+
+
+}

python/953_Verifying_an_Alien_Dictionary.py

@@ -0,0 +1,32 @@
+class Solution(object):
+    def isAlienSorted(self, words, order):
+        """
+        :type words: List[str]
+        :type order: str
+        :rtype: bool
+        """
+        order_map = {}
+        for i, v in enumerate(order):
+            order_map[v] = i
+
+        def cmp_alien(x, y):
+            ls = min(len(x), len(y))
+            index = 0
+            while index < ls:
+                if x[index] != y[index]:
+                    return order_map[x[index]] - order_map[y[index]]
+                index += 1
+            return len(x) - len(y)
+        pos = 0
+        while pos + 1 < len(words):
+            if cmp_alien(words[pos], words[pos + 1]) > 0:
+                return False
+            pos += 1
+        return True
+
+
+if __name__ == '__main__':
+    s = Solution()
+    print s.isAlienSorted(["hello","leetcode"], "hlabcdefgijkmnopqrstuvwxyz")
+    print s.isAlienSorted(["word","world","row"], "worldabcefghijkmnpqstuvxyz")
+    print s.isAlienSorted(["apple","app"], "abcdefghijklmnopqrstuvwxyz")

python/954_Array_of_Doubled_Pairs.py

@@ -0,0 +1,27 @@
+class Solution(object):
+    def canReorderDoubled(self, A):
+        """
+        :type A: List[int]
+        :rtype: bool
+        """
+        v_map = {}
+        A.sort(key=lambda x: abs(x))
+        for n in A:
+            v_map[n] = v_map.get(n, 0) + 1
+        for n in A:
+            if v_map[n] <= 0:
+                continue
+            if 2 * n in v_map and v_map[2 * n] > 0:
+                v_map[n] -= 1
+                v_map[2 * n] -= 1
+            else:
+                return False
+        return True
+
+
+if __name__ == '__main__':
+    s = Solution()
+    print s.canReorderDoubled([3, 1, 3, 6])
+    print s.canReorderDoubled([2, 1, 2, 6])
+    print s.canReorderDoubled([4, -2, 2, -4])
+    print s.canReorderDoubled([1, 2, 4, 16, 8, 4])