feat: add ts solution to lc problem: No.0846 (doocs#3059)

Author: rain84

solution/0800-0899/0846.Hand of Straights/README.md

@@ -169,6 +169,31 @@ func isNStraightHand(hand []int, groupSize int) bool {
 }
 ```
 
+#### TypeScript
+
+```ts
+function isNStraightHand(hand: number[], groupSize: number) {
+    const cnt: Record<number, number> = {};
+    for (const i of hand) {
+        cnt[i] = (cnt[i] ?? 0) + 1;
+    }
+
+    const keys = Object.keys(cnt).map(Number);
+    for (const i of keys) {
+        while (cnt[i]) {
+            for (let j = i; j < groupSize + i; j++) {
+                if (!cnt[j]) {
+                    return false;
+                }
+                cnt[j]--;
+            }
+        }
+    }
+
+    return true;
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
@@ -299,6 +324,40 @@ func isNStraightHand(hand []int, groupSize int) bool {
 }
 ```
 
+#### TypeScript
+
+```ts
+function isNStraightHand(hand: number[], groupSize: number): boolean {
+    const n = hand.length;
+    if (n % groupSize) {
+        return false;
+    }
+
+    const groups: number[][] = Array.from({ length: n / groupSize }, () => []);
+    hand.sort((a, b) => a - b);
+
+    for (let i = 0; i < n; i++) {
+        let isPushed = false;
+
+        for (const g of groups) {
+            if (g.length === groupSize || (g.length && hand[i] - g.at(-1)! !== 1)) {
+                continue;
+            }
+
+            g.push(hand[i]);
+            isPushed = true;
+            break;
+        }
+
+        if (!isPushed) {
+            return false;
+        }
+    }
+
+    return true;
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/0800-0899/0846.Hand of Straights/README_EN.md

@@ -160,6 +160,31 @@ func isNStraightHand(hand []int, groupSize int) bool {
 }
 ```
 
+#### TypeScript
+
+```ts
+function isNStraightHand(hand: number[], groupSize: number) {
+    const cnt: Record<number, number> = {};
+    for (const i of hand) {
+        cnt[i] = (cnt[i] ?? 0) + 1;
+    }
+
+    const keys = Object.keys(cnt).map(Number);
+    for (const i of keys) {
+        while (cnt[i]) {
+            for (let j = i; j < groupSize + i; j++) {
+                if (!cnt[j]) {
+                    return false;
+                }
+                cnt[j]--;
+            }
+        }
+    }
+
+    return true;
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
@@ -284,6 +309,40 @@ func isNStraightHand(hand []int, groupSize int) bool {
 }
 ```
 
+#### TypeScript
+
+```ts
+function isNStraightHand(hand: number[], groupSize: number): boolean {
+    const n = hand.length;
+    if (n % groupSize) {
+        return false;
+    }
+
+    const groups: number[][] = Array.from({ length: n / groupSize }, () => []);
+    hand.sort((a, b) => a - b);
+
+    for (let i = 0; i < n; i++) {
+        let isPushed = false;
+
+        for (const g of groups) {
+            if (g.length === groupSize || (g.length && hand[i] - g.at(-1)! !== 1)) {
+                continue;
+            }
+
+            g.push(hand[i]);
+            isPushed = true;
+            break;
+        }
+
+        if (!isPushed) {
+            return false;
+        }
+    }
+
+    return true;
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/0800-0899/0846.Hand of Straights/Solution.ts

@@ -0,0 +1,20 @@
+function isNStraightHand(hand: number[], groupSize: number) {
+    const cnt: Record<number, number> = {};
+    for (const i of hand) {
+        cnt[i] = (cnt[i] ?? 0) + 1;
+    }
+
+    const keys = Object.keys(cnt).map(Number);
+    for (const i of keys) {
+        while (cnt[i]) {
+            for (let j = i; j < groupSize + i; j++) {
+                if (!cnt[j]) {
+                    return false;
+                }
+                cnt[j]--;
+            }
+        }
+    }
+
+    return true;
+}

solution/0800-0899/0846.Hand of Straights/Solution2.ts

@@ -0,0 +1,29 @@
+function isNStraightHand(hand: number[], groupSize: number): boolean {
+    const n = hand.length;
+    if (n % groupSize) {
+        return false;
+    }
+
+    const groups: number[][] = Array.from({ length: n / groupSize }, () => []);
+    hand.sort((a, b) => a - b);
+
+    for (let i = 0; i < n; i++) {
+        let isPushed = false;
+
+        for (const g of groups) {
+            if (g.length === groupSize || (g.length && hand[i] - g.at(-1)! !== 1)) {
+                continue;
+            }
+
+            g.push(hand[i]);
+            isPushed = true;
+            break;
+        }
+
+        if (!isPushed) {
+            return false;
+        }
+    }
+
+    return true;
+}