✨ feat: 扑克牌中的顺子

Author: Reaper622

DataStructure/Array/IsContinous.js

@@ -0,0 +1,39 @@
+"use strict";
+exports.__esModule = true;
+/**
+ * 判断传入的一组扑克牌是否为一个顺子,2-10为数字本身，A为1，J为11，Q为12，K为13，大小王可为任意数字。
+ * @param {number[]} numbers
+ * @return {boolean}
+ */
+function IsContinuous(numbers) {
+    // 判断边界条件
+    if (numbers === null || numbers.length < 1) {
+        return false;
+    }
+    // 首先对numbers进行排序
+    numbers = numbers.sort(function (a, b) { return (a - b); });
+    var len = numbers.length;
+    // 内部含有大小王的个数 大小王用0表示
+    var numberOfZero = 0;
+    // 内部间隔大小 2,4 表示1个间隔 2,5表示两个间隔
+    var numberOfGap = 0;
+    // 统计这组牌中大小王的个数
+    for (var i = 0; i < len && numbers[i] === 0; i++) {
+        numberOfZero++;
+    }
+    // 统计间隔大小
+    var small = numberOfZero;
+    var big = small + 1;
+    while (big < len) {
+        // 如果有对子 那么就不会为顺子
+        if (numbers[small] === numbers[big]) {
+            return false;
+        }
+        numberOfGap += numbers[big] - numbers[small] - 1;
+        small = big;
+        big++;
+    }
+    // 如果间隔数大于大小王的个数 那么就不为顺子
+    return numberOfGap > numberOfZero ? false : true;
+}
+exports.IsContinuous = IsContinuous;

DataStructure/Array/IsContinous.ts

@@ -0,0 +1,39 @@
+
+/**
+ * 判断传入的一组扑克牌是否为一个顺子,2-10为数字本身，A为1，J为11，Q为12，K为13，大小王可为任意数字。
+ * @param {number[]} numbers 
+ * @return {boolean}
+ */
+function IsContinuous (numbers: number[]): boolean {
+    // 判断边界条件
+    if (numbers === null || numbers.length < 1) {
+        return false;
+    }
+    // 首先对numbers进行排序
+    numbers = numbers.sort((a,b) => (a-b));
+    let len = numbers.length;
+    // 内部含有大小王的个数 大小王用0表示
+    let numberOfZero = 0;
+    // 内部间隔大小 2,4 表示1个间隔 2,5表示两个间隔
+    let numberOfGap = 0;
+    // 统计这组牌中大小王的个数
+    for(let i = 0; i < len && numbers[i] === 0; i++) {
+        numberOfZero++;
+    }
+    // 统计间隔大小
+    let small = numberOfZero;
+    let big = small + 1;
+    while(big < len) {
+        // 如果有对子 那么就不会为顺子
+        if (numbers[small] === numbers[big]) {
+            return false;
+        }
+        numberOfGap += numbers[big] - numbers[small] - 1;
+        small = big;
+        big++;
+    }
+    // 如果间隔数大于大小王的个数 那么就不为顺子
+    return numberOfGap > numberOfZero ? false : true
+}
+
+export {IsContinuous}

DataStructure/Test/Array.test.js

@@ -10,6 +10,7 @@ import {FindGreatestSum} from '../Array/FindGreatestSum'
 import {ReverseString} from '../Array/Reverse'
 import {MoveZero} from '../Array/MoveZero'
 import {ReorderOddEven} from '../Array/ReorderOddEven'
+import {IsContinuous} from '../Array/IsContinous'
 
 test('FindNumWithSum', () => {
     expect(FindNumWithSum([1,2,3,4,5,6,7,8], 11)).toEqual([3,8])
@@ -58,4 +59,10 @@ test('MoveZero', () => {
 
 test('ReorderOddEven', () => {
     expect(ReorderOddEven([1,3,4,5,6,7,8])).toEqual([1,3,7,5,6,4,8])
+})
+
+test('IsContinous', () => {
+    expect(IsContinuous([1,3,4,5,0])).toBe(true)
+    expect(IsContinuous([1,3,4,5,7])).toBe(false)
+    expect(IsContinuous([0,1,4,2,4])).toBe(false)
 })

docs/README.md

@@ -60,6 +60,7 @@ Questions on LeetCode
     - 连续子数组的最大和 | 剑指Offer [31]
     - 反转字符串 | LeetCode [344]
     - 按奇偶排序数组 | LeetCode [905] | 剑指Offer [14]
+    - 扑克牌的顺子 | 剑指Offer [44]
 
 ### [字符串](./ds/String.md)
     - 最长公共前缀 | LeetCode [14]

docs/ds/Array.md

@@ -556,3 +556,48 @@ function FindGreatestSum (array: number[]):number {
 }
 ```
 
+## 判断是否为扑克牌顺子
+
+> 此部分代码在 IsContinuous.ts 中
+
+判断传入的一组扑克牌是否为一个顺子,2-10为数字本身，A为1，J为11，Q为12，K为13，大小王可为任意数字。
+
+```typescript
+/**
+ * 判断传入的一组扑克牌是否为一个顺子,2-10为数字本身，A为1，J为11，Q为12，K为13，大小王可为任意数字。
+ * @param {number[]} numbers 
+ * @return {boolean}
+ */
+function IsContinuous (numbers: number[]): boolean {
+    // 判断边界条件
+    if (numbers === null || numbers.length < 1) {
+        return false;
+    }
+    // 首先对numbers进行排序
+    numbers = numbers.sort((a,b) => (a-b));
+    let len = numbers.length;
+    // 内部含有大小王的个数 大小王用0表示
+    let numberOfZero = 0;
+    // 内部间隔大小 2,4 表示1个间隔 2,5表示两个间隔
+    let numberOfGap = 0;
+    // 统计这组牌中大小王的个数
+    for(let i = 0; i < len && numbers[i] === 0; i++) {
+        numberOfZero++;
+    }
+    // 统计间隔大小
+    let small = numberOfZero;
+    let big = small + 1;
+    while(big < len) {
+        // 如果有对子 那么就不会为顺子
+        if (numbers[small] === numbers[big]) {
+            return false;
+        }
+        numberOfGap += numbers[big] - numbers[small] - 1;
+        small = big;
+        big++;
+    }
+    // 如果间隔数大于大小王的个数 那么就不为顺子
+    return numberOfGap > numberOfZero ? false : true
+}
+```
+