feat: add solutions to lc problem: No.1237

No.1237.Find Positive Integer Solution for a Given Equation

Author: yanglbme

solution/1200-1299/1237.Find Positive Integer Solution for a Given Equation/README.md

@@ -95,19 +95,41 @@ x=5, y=1 -> f(5, 1) = 5 * 1 = 5</pre>
 
 
 class Solution:
-    def findSolution(self, customfunction: 'CustomFunction', z: int) -> List[List[int]]:
-        res = []
+    def findSolution(self, customfunction: "CustomFunction", z: int) -> List[List[int]]:
+        ans = []
         for x in range(1, 1001):
-            left, right = 1, 1000
-            while left < right:
-                mid = (left + right) >> 1
-                if customfunction.f(x, mid) >= z:
-                    right = mid
-                else:
-                    left = mid + 1
-            if customfunction.f(x, left) == z:
-                res.append([x, left])
-        return res
+            y = 1 + bisect_left(range(1, 1001), z, key=lambda y: customfunction.f(x, y))
+            if customfunction.f(x, y) == z:
+                ans.append([x, y])
+        return ans
+```
+
+```python
+"""
+   This is the custom function interface.
+   You should not implement it, or speculate about its implementation
+   class CustomFunction:
+       # Returns f(x, y) for any given positive integers x and y.
+       # Note that f(x, y) is increasing with respect to both x and y.
+       # i.e. f(x, y) < f(x + 1, y), f(x, y) < f(x, y + 1)
+       def f(self, x, y):
+  
+"""
+
+class Solution:
+    def findSolution(self, customfunction: 'CustomFunction', z: int) -> List[List[int]]:
+        ans = []
+        x, y = 1, 1000
+        while x <= 1000 and y:
+            t = customfunction.f(x, y)
+            if t < z:
+                x += 1
+            elif t > z:
+                y -= 1
+            else:
+                ans.append([x, y])
+                x, y = x + 1, y - 1
+        return ans
 ```
 
 ### **Java**
@@ -126,58 +148,56 @@ class Solution:
  * };
  */
 
-class Solution {
+ class Solution {
     public List<List<Integer>> findSolution(CustomFunction customfunction, int z) {
-        List<List<Integer>> res = new ArrayList<>();
-        for (int i = 1; i <= 1000; ++i) {
-            int left = 1, right = 1000;
-            while (left < right) {
-                int mid = (left + right) >> 1;
-                if (customfunction.f(i, mid) >= z) {
-                    right = mid;
+        List<List<Integer>> ans = new ArrayList<>();
+        for (int x = 1; x <= 1000; ++x) {
+            int l = 1, r = 1000;
+            while (l < r) {
+                int mid = (l + r) >> 1;
+                if (customfunction.f(x, mid) >= z) {
+                    r = mid;
                 } else {
-                    left = mid + 1;
+                    l = mid + 1;
                 }
             }
-            if (customfunction.f(i, left) == z) {
-                res.add(Arrays.asList(i, left));
+            if (customfunction.f(x, l) == z) {
+                ans.add(Arrays.asList(x, l));
             }
         }
-        return res;
+        return ans;
     }
 }
 ```
 
-### **TypeScript**
-
-```ts
-/**
- * // This is the CustomFunction's API interface.
+```java
+/*
+ * // This is the custom function interface.
  * // You should not implement it, or speculate about its implementation
  * class CustomFunction {
- *      f(x: number, y: number): number {}
- * }
+ *     // Returns f(x, y) for any given positive integers x and y.
+ *     // Note that f(x, y) is increasing with respect to both x and y.
+ *     // i.e. f(x, y) < f(x + 1, y), f(x, y) < f(x, y + 1)
+ *     public int f(int x, int y);
+ * };
  */
 
-function findSolution(customfunction: CustomFunction, z: number): number[][] {
-    // 二分
-    let ans = [];
-    for (let i = 1; i <= 1000; i++) {
-        let left = 1,
-            right = 1000;
-        while (left < right) {
-            let mid = (left + right) >> 1;
-            if (customfunction.f(i, mid) >= z) {
-                right = mid;
+class Solution {
+    public List<List<Integer>> findSolution(CustomFunction customfunction, int z) {
+        List<List<Integer>> ans = new ArrayList<>();
+        int x = 1, y = 1000;
+        while (x <= 1000 && y > 0) {
+            int t = customfunction.f(x, y);
+            if (t < z) {
+                ++x;
+            } else if (t > z) {
+                --y;
             } else {
-                left = mid + 1;
+                ans.add(Arrays.asList(x++, y--));
             }
         }
-        if (customfunction.f(i, left) == z) {
-            ans.push([i, left]);
-        }
+        return ans;
     }
-    return ans;
 }
 ```
 
@@ -199,22 +219,55 @@ function findSolution(customfunction: CustomFunction, z: number): number[][] {
 class Solution {
 public:
     vector<vector<int>> findSolution(CustomFunction& customfunction, int z) {
-        vector<vector<int>> res;
-        for (int i = 1; i <= 1000; ++i) {
-            int left = 1, right = 1000;
-            while (left < right) {
-                int mid = left + right >> 1;
-                if (customfunction.f(i, mid) >= z) {
-                    right = mid;
+        vector<vector<int>> ans;
+        for (int x = 1; x <= 1000; ++x) {
+            int l = 1, r = 1000;
+            while (l < r) {
+                int mid = (l + r) >> 1;
+                if (customfunction.f(x, mid) >= z) {
+                    r = mid;
                 } else {
-                    left = mid + 1;
+                    l = mid + 1;
                 }
             }
-            if (customfunction.f(i, left) == z) {
-                res.push_back({i, left});
+            if (customfunction.f(x, l) == z) {
+                ans.push_back({x, l});
             }
         }
-        return res;
+        return ans;
+    }
+};
+```
+
+```cpp
+/*
+ * // This is the custom function interface.
+ * // You should not implement it, or speculate about its implementation
+ * class CustomFunction {
+ * public:
+ *     // Returns f(x, y) for any given positive integers x and y.
+ *     // Note that f(x, y) is increasing with respect to both x and y.
+ *     // i.e. f(x, y) < f(x + 1, y), f(x, y) < f(x, y + 1)
+ *     int f(int x, int y);
+ * };
+ */
+
+class Solution {
+public:
+    vector<vector<int>> findSolution(CustomFunction& customfunction, int z) {
+        vector<vector<int>> ans;
+        int x = 1, y = 1000;
+        while (x <= 1000 && y) {
+            int t = customfunction.f(x, y);
+            if (t < z) {
+                ++x;
+            } else if (t > z) {
+                --y;
+            } else {
+                ans.push_back({x++, y--});
+            }
+        }
+        return ans;
     }
 };
 ```
@@ -231,23 +284,100 @@ public:
  *              i.e. f(x, y) < f(x + 1, y), f(x, y) < f(x, y + 1)
  */
 
-func findSolution(customFunction func(int, int) int, z int) [][]int {
-	res := [][]int{}
-	for i := 1; i <= 1000; i++ {
-		left, right := 1, 1000
-		for left < right {
-			mid := (left + right) >> 1
-			if customFunction(i, mid) >= z {
-				right = mid
-			} else {
-				left = mid + 1
-			}
+func findSolution(customFunction func(int, int) int, z int) (ans [][]int) {
+	for x := 1; x <= 1000; x++ {
+		y := 1 + sort.Search(999, func(y int) bool { return customFunction(x, y+1) >= z })
+		if customFunction(x, y) == z {
+			ans = append(ans, []int{x, y})
 		}
-		if customFunction(i, left) == z {
-			res = append(res, []int{i, left})
+	}
+	return
+}
+```
+
+```go
+/**
+ * This is the declaration of customFunction API.
+ * @param  x    int
+ * @param  x    int
+ * @return 	    Returns f(x, y) for any given positive integers x and y.
+ *			    Note that f(x, y) is increasing with respect to both x and y.
+ *              i.e. f(x, y) < f(x + 1, y), f(x, y) < f(x, y + 1)
+ */
+
+func findSolution(customFunction func(int, int) int, z int) (ans [][]int) {
+	x, y := 1, 1000
+	for x <= 1000 && y > 0 {
+		t := customFunction(x, y)
+		if t < z {
+			x++
+		} else if t > z {
+			y--
+		} else {
+			ans = append(ans, []int{x, y})
+			x, y = x+1, y-1
 		}
 	}
-	return res
+	return
+}
+```
+
+### **TypeScript**
+
+```ts
+/**
+ * // This is the CustomFunction's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * class CustomFunction {
+ *      f(x: number, y: number): number {}
+ * }
+ */
+
+function findSolution(customfunction: CustomFunction, z: number): number[][] {
+    const ans: number[][] = [];
+    for (let x = 1; x <= 1000; ++x) {
+        let l = 1;
+        let r = 1000;
+        while (l < r) {
+            const mid = (l + r) >> 1;
+            if (customfunction.f(x, mid) >= z) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        }
+        if (customfunction.f(x, l) == z) {
+            ans.push([x, l]);
+        }
+    }
+    return ans;
+}
+```
+
+```ts
+/**
+ * // This is the CustomFunction's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * class CustomFunction {
+ *      f(x: number, y: number): number {}
+ * }
+ */
+
+function findSolution(customfunction: CustomFunction, z: number): number[][] {
+    let x = 1;
+    let y = 1000;
+    const ans: number[][] = [];
+    while (x <= 1000 && y) {
+        const t = customfunction.f(x, y);
+        if (t < z) {
+            ++x;
+        } else if (t > z) {
+            --y;
+        } else {
+            ans.push([x--, y--]);
+        }
+    }
+    return ans;
 }
 ```