feat: add solutions to lc problem: No.3394

solution/3300-3399/3394.Check if Grid can be Cut into Sections/README.md

@@ -291,6 +291,66 @@ func checkValidCuts(n int, rectangles [][]int) bool {
 }
 ```
 
+#### TypeScript
+
+```ts
+function checkValidCuts(n: number, rectangles: number[][]): boolean {
+    const check = (arr: number[][], getVals: (x: number[]) => number[]) => {
+        let [c, longest] = [3, 0];
+
+        for (const x of arr) {
+            const [start, end] = getVals(x);
+
+            if (start < longest) {
+                longest = Math.max(longest, end);
+            } else {
+                longest = end;
+                if (--c === 0) return true;
+            }
+        }
+
+        return false;
+    };
+
+    const sortByX = ([a]: number[], [b]: number[]) => a - b;
+    const sortByY = ([, a]: number[], [, b]: number[]) => a - b;
+    const getX = ([x1, , x2]: number[]) => [x1, x2];
+    const getY = ([, y1, , y2]: number[]) => [y1, y2];
+
+    return check(rectangles.toSorted(sortByX), getX) || check(rectangles.toSorted(sortByY), getY);
+}
+```
+
+#### JavaScript
+
+```js
+function checkValidCuts(n, rectangles) {
+    const check = (arr, getVals) => {
+        let [c, longest] = [3, 0];
+
+        for (const x of arr) {
+            const [start, end] = getVals(x);
+
+            if (start < longest) {
+                longest = Math.max(longest, end);
+            } else {
+                longest = end;
+                if (--c === 0) return true;
+            }
+        }
+
+        return false;
+    };
+
+    const sortByX = ([a], [b]) => a - b;
+    const sortByY = ([, a], [, b]) => a - b;
+    const getX = ([x1, , x2]) => [x1, x2];
+    const getY = ([, y1, , y2]) => [y1, y2];
+
+    return check(rectangles.toSorted(sortByX), getX) || check(rectangles.toSorted(sortByY), getY);
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3300-3399/3394.Check if Grid can be Cut into Sections/README_EN.md

@@ -121,6 +121,66 @@ tags:
 
 ```
 
+#### TypeScript
+
+```ts
+function checkValidCuts(n: number, rectangles: number[][]): boolean {
+    const check = (arr: number[][], getVals: (x: number[]) => number[]) => {
+        let [c, longest] = [3, 0];
+
+        for (const x of arr) {
+            const [start, end] = getVals(x);
+
+            if (start < longest) {
+                longest = Math.max(longest, end);
+            } else {
+                longest = end;
+                if (--c === 0) return true;
+            }
+        }
+
+        return false;
+    };
+
+    const sortByX = ([a]: number[], [b]: number[]) => a - b;
+    const sortByY = ([, a]: number[], [, b]: number[]) => a - b;
+    const getX = ([x1, , x2]: number[]) => [x1, x2];
+    const getY = ([, y1, , y2]: number[]) => [y1, y2];
+
+    return check(rectangles.toSorted(sortByX), getX) || check(rectangles.toSorted(sortByY), getY);
+}
+```
+
+#### JavaScript
+
+```js
+function checkValidCuts(n, rectangles) {
+    const check = (arr, getVals) => {
+        let [c, longest] = [3, 0];
+
+        for (const x of arr) {
+            const [start, end] = getVals(x);
+
+            if (start < longest) {
+                longest = Math.max(longest, end);
+            } else {
+                longest = end;
+                if (--c === 0) return true;
+            }
+        }
+
+        return false;
+    };
+
+    const sortByX = ([a], [b]) => a - b;
+    const sortByY = ([, a], [, b]) => a - b;
+    const getX = ([x1, , x2]) => [x1, x2];
+    const getY = ([, y1, , y2]) => [y1, y2];
+
+    return check(rectangles.toSorted(sortByX), getX) || check(rectangles.toSorted(sortByY), getY);
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3300-3399/3394.Check if Grid can be Cut into Sections/Solution.js

@@ -0,0 +1,25 @@
+function checkValidCuts(n, rectangles) {
+    const check = (arr, getVals) => {
+        let [c, longest] = [3, 0];
+
+        for (const x of arr) {
+            const [start, end] = getVals(x);
+
+            if (start < longest) {
+                longest = Math.max(longest, end);
+            } else {
+                longest = end;
+                if (--c === 0) return true;
+            }
+        }
+
+        return false;
+    };
+
+    const sortByX = ([a], [b]) => a - b;
+    const sortByY = ([, a], [, b]) => a - b;
+    const getX = ([x1, , x2]) => [x1, x2];
+    const getY = ([, y1, , y2]) => [y1, y2];
+
+    return check(rectangles.toSorted(sortByX), getX) || check(rectangles.toSorted(sortByY), getY);
+}

solution/3300-3399/3394.Check if Grid can be Cut into Sections/Solution.ts

@@ -0,0 +1,25 @@
+function checkValidCuts(n: number, rectangles: number[][]): boolean {
+    const check = (arr: number[][], getVals: (x: number[]) => number[]) => {
+        let [c, longest] = [3, 0];
+
+        for (const x of arr) {
+            const [start, end] = getVals(x);
+
+            if (start < longest) {
+                longest = Math.max(longest, end);
+            } else {
+                longest = end;
+                if (--c === 0) return true;
+            }
+        }
+
+        return false;
+    };
+
+    const sortByX = ([a]: number[], [b]: number[]) => a - b;
+    const sortByY = ([, a]: number[], [, b]: number[]) => a - b;
+    const getX = ([x1, , x2]: number[]) => [x1, x2];
+    const getY = ([, y1, , y2]: number[]) => [y1, y2];
+
+    return check(rectangles.toSorted(sortByX), getX) || check(rectangles.toSorted(sortByY), getY);
+}