连续值数组值

Question

当函数为真时，我用一个计数器建立一个数组。

因此，如果连续3次为真，则该数组看起来像[1,2,3]。 如果该函数不正确，则计数器中将存在间隙，并且可能看起来像[1,2,3,5]。

在另一个函数中，我需要确定数组长度是否大于2，并且数组中的值是连续的。 因此[1,2,3]应该返回true。 如果[1,2,3,5]应该返回false。

我还没有发现任何有效的方法。 任何可能的解决方案的帮助将不胜感激。

我已经看过（并尝试过），但是它不起作用。

Array.prototype.is_consecutive = (function () {
    var offset = 0; // remember the last offset
    return function () {
        var start = offset, len = this.length;
        for (var i = start + 1; i < len; i++) {
            if (this[i] !== this[i - 1] + 1) {
                break;
            }
        }
        offset = i;
        return this[start];
    };
})();

Answer 1

如果您绝对可以按照所述规则依赖于填充数组的算法

当函数为真时，我用一个计数器建立一个数组。 因此，如果连续3次为真，则该数组看起来像[1,2,3]。 如果该函数不正确，则计数器中将存在间隙，并且可能看起来像[1,2,3,5]。

然后，您所需要做的就是检查数组的最后一个元素与数组的长度是否具有相同的值：

 var good = [1, 2, 3]; var bad = [1, 2, 3, 5]; var isValid = function(arr) { return (arr.length > 2 && arr[arr.length - 1] === arr.length); // Thanks to Jonas W. } console.log(isValid(good)); console.log(isValid(bad)); 

Answer 2

您可以对第一个索引值使用闭包，并在检查时递增该值。

 function isConsecutive(array) { return array.length >= 2 && array.every((v => a => a === v++)(array[0])); } console.log([[1, 2, 3, 4], [1, 2, 3, 5]].map(isConsecutive)); 

Answer 3

 Array.prototype.isConsecutive = function(){
   for(var i = 1; i < this.length; i++)
     if(this[i] !== this[i - 1] + 1)
        return false;
   return true;
 };

或混淆的版本：

  const isConsecutive = arr => !!arr.reduce((prev, curr) => curr === prev + 1 ? curr : 0);

Answer 4

 var array=[5,6,7,8]; function continuous(arr){ var max = Math.max(...arr); var min = Math.min(...arr); return (((max-min)+1) * (min + max) / 2) == arr.reduce((a, b) => a + b, 0) } console.log(continuous(array)) 

Answer 5

您也可以使用它，它是递归的：

 Array.prototype.isConsecutive = function(){ if (arguments.length==0) return this.isConsecutive(0); else if (arguments[0]>=this.length) return true; else return (this[arguments[0]]==arguments[0]+1&&this.isConsecutive(arguments[0]+1 ));} cons=[1,2,3]; console.log(cons.isConsecutive()); non_cons=[1,2,2,4]; console.log(non_cons.isConsecutive());