1064_Fixed_Point

Author: qiyuangong

README.md

@@ -207,6 +207,7 @@ Also, there are open source implementations for basic data structs and algorithm
 | 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) |
 | 961 | [N-Repeated Element in Size 2N Array](https://leetcode.com/problems/n-repeated-element-in-size-2n-array/submissions/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/961_N-Repeated_Element_in_Size_2N_Array.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/961_N-Repeated_Element_in_Size_2N_Array.java) | Hash and count number, O(n) and O(n) |
 | 962 | [Maximum Width Ramp](https://leetcode.com/problems/maximum-width-ramp/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/962_Maximum_Width_Ramp.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/962_Maximum_Width_Ramp.java) | 1. Sort index by value, then transfer problem into finding max gap between index, O(nlogn) and O(1)<br>2. Binary Search for candicates, O(nlogn) and O(n) |
+| 1064 | [Fixed Point](https://leetcode.com/problems/fixed-point/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/1064_Fixed_Point.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/1064_Fixed_Point.java) | 1. Go through index and value, until find solution encounter index < value, O(n) and O(1)<br>2. Binary search, O(logn) and O(1) |
 
 | # | To Understand |
 |---| ----- |

java/1064_Fixed_Point.java

@@ -0,0 +1,21 @@
+class Solution {
+    /* public int fixedPoint(int[] A) {
+        for (int i = 0; i < A.length; i++) {
+            // Because if A[i] > i, then i can never be greater than A[i] any more
+            if (A[i] == i) return i;
+            else if (A[i] > i) return -1;
+        }
+        return -1;
+    } */
+    public int fixedPoint(int[] A) {
+        int l = 0;
+        int h = A.length;
+        while (l <= h) {
+            int mid = (l + h) / 2;
+            if (A[mid] > mid) h = mid - 1;
+            else if (A[mid] < mid) l = mid + 1;
+            else return mid;
+        }
+        return -1;
+    }
+}

python/1064_Fixed_Point.py

@@ -0,0 +1,24 @@
+class Solution(object):
+    # def fixedPoint(self, A):
+    #     """
+    #     :type A: List[int]
+    #     :rtype: int
+    #     """
+    #     for index, value in enumerate(A):
+    #         # Because if A[i] > i, then i can never be greater than A[i] any more
+    #         if index == value:
+    #             return index
+    #         elif index < value:
+    #             return -1
+
+    def fixedPoint(self, A):
+        l, h = 0, len(A) - 1
+        while l <= h:
+            mid = (l + h) // 2
+            if A[mid] < mid:
+                l = mid + 1
+            elif A[mid] > mid:
+                h = mid - 1
+            else:
+                return mid
+        return -1