feat: add solutions to lc problem: No.2040 (#4487)

No.2040.Kth Smallest Product of Two Sorted Arrays

Author: yanglbme

solution/2000-2099/2040.Kth Smallest Product of Two Sorted Arrays/README.md

@@ -293,6 +293,69 @@ func abs(x int) int {
 }
 ```
 
+#### TypeScript
+
+```ts
+function kthSmallestProduct(nums1: number[], nums2: number[], k: number): number {
+    const m = nums1.length;
+    const n = nums2.length;
+
+    const a = BigInt(Math.max(Math.abs(nums1[0]), Math.abs(nums1[m - 1])));
+    const b = BigInt(Math.max(Math.abs(nums2[0]), Math.abs(nums2[n - 1])));
+
+    let l = -a * b;
+    let r = a * b;
+
+    const count = (p: bigint): bigint => {
+        let cnt = 0n;
+        for (const x of nums1) {
+            const bx = BigInt(x);
+            if (bx > 0n) {
+                let l = 0,
+                    r = n;
+                while (l < r) {
+                    const mid = (l + r) >> 1;
+                    const prod = bx * BigInt(nums2[mid]);
+                    if (prod > p) {
+                        r = mid;
+                    } else {
+                        l = mid + 1;
+                    }
+                }
+                cnt += BigInt(l);
+            } else if (bx < 0n) {
+                let l = 0,
+                    r = n;
+                while (l < r) {
+                    const mid = (l + r) >> 1;
+                    const prod = bx * BigInt(nums2[mid]);
+                    if (prod <= p) {
+                        r = mid;
+                    } else {
+                        l = mid + 1;
+                    }
+                }
+                cnt += BigInt(n - l);
+            } else if (p >= 0n) {
+                cnt += BigInt(n);
+            }
+        }
+        return cnt;
+    };
+
+    while (l < r) {
+        const mid = (l + r) >> 1n;
+        if (count(mid) >= BigInt(k)) {
+            r = mid;
+        } else {
+            l = mid + 1n;
+        }
+    }
+
+    return Number(l);
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2000-2099/2040.Kth Smallest Product of Two Sorted Arrays/README_EN.md

@@ -294,6 +294,69 @@ func abs(x int) int {
 }
 ```
 
+#### TypeScript
+
+```ts
+function kthSmallestProduct(nums1: number[], nums2: number[], k: number): number {
+    const m = nums1.length;
+    const n = nums2.length;
+
+    const a = BigInt(Math.max(Math.abs(nums1[0]), Math.abs(nums1[m - 1])));
+    const b = BigInt(Math.max(Math.abs(nums2[0]), Math.abs(nums2[n - 1])));
+
+    let l = -a * b;
+    let r = a * b;
+
+    const count = (p: bigint): bigint => {
+        let cnt = 0n;
+        for (const x of nums1) {
+            const bx = BigInt(x);
+            if (bx > 0n) {
+                let l = 0,
+                    r = n;
+                while (l < r) {
+                    const mid = (l + r) >> 1;
+                    const prod = bx * BigInt(nums2[mid]);
+                    if (prod > p) {
+                        r = mid;
+                    } else {
+                        l = mid + 1;
+                    }
+                }
+                cnt += BigInt(l);
+            } else if (bx < 0n) {
+                let l = 0,
+                    r = n;
+                while (l < r) {
+                    const mid = (l + r) >> 1;
+                    const prod = bx * BigInt(nums2[mid]);
+                    if (prod <= p) {
+                        r = mid;
+                    } else {
+                        l = mid + 1;
+                    }
+                }
+                cnt += BigInt(n - l);
+            } else if (p >= 0n) {
+                cnt += BigInt(n);
+            }
+        }
+        return cnt;
+    };
+
+    while (l < r) {
+        const mid = (l + r) >> 1n;
+        if (count(mid) >= BigInt(k)) {
+            r = mid;
+        } else {
+            l = mid + 1n;
+        }
+    }
+
+    return Number(l);
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2000-2099/2040.Kth Smallest Product of Two Sorted Arrays/Solution.ts

@@ -0,0 +1,58 @@
+function kthSmallestProduct(nums1: number[], nums2: number[], k: number): number {
+    const m = nums1.length;
+    const n = nums2.length;
+
+    const a = BigInt(Math.max(Math.abs(nums1[0]), Math.abs(nums1[m - 1])));
+    const b = BigInt(Math.max(Math.abs(nums2[0]), Math.abs(nums2[n - 1])));
+
+    let l = -a * b;
+    let r = a * b;
+
+    const count = (p: bigint): bigint => {
+        let cnt = 0n;
+        for (const x of nums1) {
+            const bx = BigInt(x);
+            if (bx > 0n) {
+                let l = 0,
+                    r = n;
+                while (l < r) {
+                    const mid = (l + r) >> 1;
+                    const prod = bx * BigInt(nums2[mid]);
+                    if (prod > p) {
+                        r = mid;
+                    } else {
+                        l = mid + 1;
+                    }
+                }
+                cnt += BigInt(l);
+            } else if (bx < 0n) {
+                let l = 0,
+                    r = n;
+                while (l < r) {
+                    const mid = (l + r) >> 1;
+                    const prod = bx * BigInt(nums2[mid]);
+                    if (prod <= p) {
+                        r = mid;
+                    } else {
+                        l = mid + 1;
+                    }
+                }
+                cnt += BigInt(n - l);
+            } else if (p >= 0n) {
+                cnt += BigInt(n);
+            }
+        }
+        return cnt;
+    };
+
+    while (l < r) {
+        const mid = (l + r) >> 1n;
+        if (count(mid) >= BigInt(k)) {
+            r = mid;
+        } else {
+            l = mid + 1n;
+        }
+    }
+
+    return Number(l);
+}