401_Binary_Watch and 405_Convert_a_Number_to_Hexadecimal

Author: qiyuangong

README.md

@@ -1,8 +1,8 @@
 # Python & JAVA Solutions for Leetcode (inspired by [haoel's leetcode](https://github.com/haoel/leetcode))
 
-[Python](https://github.com/qiyuangong/leetcode/tree/master/python) and [Java](https://github.com/qiyuangong/leetcode/tree/master/java) full list
+Remember solutions are only solutions to given problems. If you want full study checklist for code & whiteboard interview, please turn to [jwasham's coding-interview-university](https://github.com/jwasham/coding-interview-university).
 
-♥ means you need a subscription.
+[Python](https://github.com/qiyuangong/leetcode/tree/master/python) and [Java](https://github.com/qiyuangong/leetcode/tree/master/java) full list. ♥ means you need a subscription.
 
 | # | Title | Solution | Basic idea (One line) |
 |---| ----- | -------- | --------------------- |
@@ -118,7 +118,9 @@
 | 387 | [First Unique Character in a String](https://leetcode.com/problems/first-unique-character-in-a-string/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/387_First_Unique_Character_in_a_String.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/387_First_Unique_Character_in_a_String.java) | Get frequency of each letter, return first letter with frequency 1, O(n) and O(1)  |
 | 388 | [Longest Absolute File Path](https://leetcode.com/problems/longest-absolute-file-path/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/388_Longest_Absolute_File_Path.py) | Store last length and rindex, O(n) and O(n) |
 | 389 | [Find the Difference](https://leetcode.com/problems/find-the-difference/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/389_Find_the_Difference.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/389_Find_the_Difference.java) | 1. Imaging letter a as 0, then the sum(t)-sum(s) is the result<br> 2. Based on solution 1, bit manipulate |
+| 401 | [Binary Watch](https://leetcode.com/problems/binary-watch/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/401_Binary_Watch.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/401_Binary_Watch.java) | Note that 12 * 60 is much less than 2^n or n^2. |
 | 404 | [Sum of Left Leaves](https://leetcode.com/problems/sum-of-left-leaves/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/404_Sum_of_Left_Leaves.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/404_Sum_of_Left_Leaves.java) | 1. Recursively DFS with root.left.left and root.left.right check<br>2. The same DFS based on stack |
+| 405 | [Convert a Number to Hexadecimal](https://leetcode.com/problems/convert-a-number-to-hexadecimal/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/405_Convert_a_Number_to_Hexadecimal.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/405_Convert_a_Number_to_Hexadecimal.java) | [Two's complement](https://en.wikipedia.org/wiki/Two%27s_complement) 1. Bit manipulate, each time handle 4 digits<br>2. Python (hex) and Java API (toHexString & Integer.toHexString) |
 | 408 | [Valid Word Abbreviation](https://leetcode.com/problems/valid-word-abbreviation/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/408_Valid_Word_Abbreviation.py) | Go over abbr and word, O(n) and O(1) |
 | 416 | [Partition Equal Subset Sum](https://leetcode.com/problems/partition-equal-subset-sum/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/416_Partition_Equal_Subset_Sum.py) | DP, Check if sum of some elements can be half of total sum, O(total_sum / 2 * n) and O(total_sum / 2) |
 | 421 | [Maximum XOR of Two Numbers in an Array](https://leetcode.com/problems/maximum-xor-of-two-numbers-in-an-array/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/421_Maximum_XOR_of_Two_Numbers_in_an_Array.py) | Check 0~32 prefix, check if there is x y in prefixes, where x ^ y = answer ^ 1, O(32n) and O(n) |

java/401_Binary_Watch.java

@@ -0,0 +1,10 @@
+class Solution {
+    public List<String> readBinaryWatch(int num) {
+        List<String> times = new ArrayList<>();
+        for (int h = 0; h < 12; h++)
+            for (int m = 0; m < 60; m++)
+                if (Integer.bitCount(h * 64 + m) == num)
+                    times.add(String.format("%d:%02d", h, m));
+        return times; 
+    }
+}

java/405_Convert_a_Number_to_Hexadecimal.java

@@ -0,0 +1,20 @@
+import com.sun.corba.se.spi.orbutil.fsm.Guard.Result;
+
+class Solution {
+    public String toHex(int num) {
+        String hex_map = "0123456789abcdef";
+        if (num == 0) return "0";
+        String res = "";
+        // To avoid infinite loop caused by negative num
+        while (num != 0 && res.length() < 8) {
+            res = hex_map.charAt(num & 15) + res;
+            num = num >> 4;
+        }
+        return res;
+    }
+
+    /* public String toHex(int num) {
+        String hex = Integer.toHexString(num);
+        return hex;
+    } */
+}

python/401_Binary_Watch.py

@@ -0,0 +1,12 @@
+class Solution(object):
+    def readBinaryWatch(self, num):
+        """
+        :type num: int
+        :rtype: List[str]
+        """
+        return ['%d:%02d' % (h, m)
+            for h in range(12) for m in range(60)
+            if (bin(h) + bin(m)).count('1') == num]
+
+
+

python/405_Convert_a_Number_to_Hexadecimal.py

@@ -0,0 +1,31 @@
+
+class Solution(object):
+    def toHex(self, num):
+        """
+        :type num: int
+        :rtype: str
+        """
+        if num == 0:
+            return '0'
+        # letter map
+        mp = '0123456789abcdef'
+        ans = ''
+        for _ in range(8):
+            # get last 4 digits
+            # num & 1111b
+            n = num & 15
+            # hex letter for current 1111
+            c = mp[n]
+            ans = c + ans
+            # num = num / 16
+            num = num >> 4
+        #strip leading zeroes
+        return ans.lstrip('0')
+    
+    # def toHex(self, num):
+    #     def tohex(val, nbits):
+    #         return hex((val + (1 << nbits)) % (1 << nbits))
+    #     return tohex(num, 32)[2:]
+
+    # def toHex(self, num, h=''):
+    #     return (not num or h[7:]) and h or self.toHex(num / 16, '0123456789abcdef'[num % 16] + h)