367 Valid Perfect Square and code style

Author: qiyuangong

README.md

@@ -108,6 +108,7 @@
 | 351 | [Android Unlock Patterns](https://leetcode.com/problems/android-unlock-patterns/) ♥ | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/351_Android_Unlock_Patterns.py) | Backtracking, O(n!) and O(n) |
 | 359 | [Logger Rate Limiter](https://leetcode.com/problems/logger-rate-limiter/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/359_Logger_Rate_Limiter.py) | 1. hash which stores the latest timestamp, O(1) and O(n)<br>2. Using Priority queue to remove older logs, O(n) and O(n) |
 | 366 | [Find Leaves of Binary Tree](https://leetcode.com/problems/find-leaves-of-binary-tree/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/366_Find_Leaves_of_Binary_Tree.py) | 1. Set or hash to check leaft, O(n^2) and O(n)<br>2. Recursively check level and return them, O(n) and O(n)|
+| 367 | [Valid Perfect Square](https://leetcode.com/problems/valid-perfect-square) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/367_Valid_Perfect_Square.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/367_Valid_Perfect_Square.java) | [Integer square root](https://en.wikipedia.org/wiki/Integer_square_root#Using_only_integer_division)<br>1. 1+3+…+(2n-1) = n^2<br>2. Binary search<br>3. Newton's method |
 | 368 | [Largest Divisible Subset](https://leetcode.com/problems/largest-divisible-subset/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/368_Largest_Divisible_Subset.py) | Sort and generate x subset with previous results, O(n^2) and O(n^2) |
 | 369 | [Plus One Linked List](https://leetcode.com/problems/plus-one-linked-list/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/369_Plus_One_Linked_List.py) | 1. Stack or list that store the list, O(n) and O(n)<br>2. Two points, the first to the tail, the second to the latest place that is not 9, O(n) and O(1) |
 | 370 | [Range Addition](https://leetcode.com/problems/range-addition/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/370_Range_Addition.py) | Interval problem with cumulative sums, O(n + k) and O(n) |

java/367_Valid_Perfect_Square.java

@@ -0,0 +1,34 @@
+class Solution {
+    /* public boolean isPerfectSquare(int num) {
+        int i = 1;
+        while (num > 0) {
+            num -= i;
+            i += 2;
+        }
+        return num == 0;
+    } */
+
+    public boolean isPerfectSquare(int num) {
+        int low = 1;
+        int high = num;
+        while (low <= high) {
+            long mid = (low + high) >>> 1;
+            if (mid * mid == num) {
+                return true;
+            } else if (mid * mid < num) {
+                low = (int) mid + 1;
+            } else {
+                high = (int) mid - 1;
+            }
+        }
+        return false;
+    }
+
+    /* public boolean isPerfectSquare(int num) {
+        long x = num;
+        while (x * x > num) {
+            x = (x + num / x) >> 1;
+        }
+        return x * x == num;
+    } */
+}

python/001_Two_Sum.py

@@ -47,20 +47,20 @@ class Solution(object):
 
     def twoSum(self, nums, target):
         # two point
-        nums_index = [(v, index)for index, v in enumerate(nums)]
+        nums_index = [(v, index) for index, v in enumerate(nums)]
         nums_index.sort()
         begin, end = 0, len(nums) - 1
         while begin < end:
             curr = nums_index[begin][0] + nums_index[end][0]
             if curr == target:
                 return [nums_index[begin][1], nums_index[end][1]]
             elif curr < target:
-                begin +=1
+                begin += 1
             else:
                 end -= 1
 
 
 if __name__ == '__main__':
     # begin
     s = Solution()
-    print s.twoSum([3,2,4], 6)
+    print s.twoSum([3, 2, 4], 6)

python/002_Add_Two_Numbers.py

@@ -4,6 +4,7 @@ def __init__(self, x):
         self.val = x
         self.next = None
 
+
 class Solution(object):
     # def addTwoNumbers(self, l1, l2):
     #     """
@@ -54,6 +55,3 @@ def addTwoNumbers(self, l1, l2):
         if carry > 0:
             curr.next = ListNode(carry)
         return head.next
-
-
-

python/003_Longest_Substring_Without_Repeating_Characters.py

@@ -66,6 +66,6 @@ def lengthOfLongestSubstring(self, s):
             # duplicate character in current i,j. So we need to update i.
             if charMap[ord(s[j])] >= i:
                 i = charMap[ord(s[j])] + 1
-            charMap[ord(s[j])]  = j
+            charMap[ord(s[j])] = j
             max_len = max(max_len, j - i + 1)
         return max_len

python/035_Search_Insert_Position.py

@@ -33,5 +33,3 @@ def searchInsert(self, nums, target):
         if nums[l] < target:
             return l + 1
         return l
-
-

python/367_Valid_Perfect_Square.py

@@ -0,0 +1,30 @@
+class Solution(object):
+    # def isPerfectSquare(self, num):
+    #     """
+    #     :type num: int
+    #     :rtype: bool
+    #     """
+    #     i = 1
+    #     while num > 0:
+    #         num -= i
+    #         i += 2
+    #     return num == 0
+
+    def isPerfectSquare(self, num):
+        low, high = 1, num
+        while low <= high:
+            mid = (low + high) / 2
+            mid_square = mid * mid
+            if mid_square == num:
+                return True
+            elif mid_square < num:
+                low = mid + 1
+            else:
+                high = mid - 1
+        return False
+
+    # def isPerfectSquare(self, num):
+    #     x = num
+    #     while x * x > num:
+    #         x = (x + num / x) / 2
+    #     return x * x == num

python/372_Super_Pow.py

@@ -13,12 +13,12 @@ def superPow(self, a, b):
         if b is None or len(b) == 0:
             return 1
         last_digit = b.pop()
-        return self.powmod(self.superPow(a, b), 10) * self.powmod(a, last_digit) % self.base
-
+        return self.powmod(self.superPow(a, b), 10) * \
+            self.powmod(a, last_digit) % self.base
 
     def powmod(self, a, k):
         a %= self.base
         result = 1
         for i in range(k):
             result = (result * a) % self.base
-        return result
+        return result