Javascript 检查数组中的项目是否连续

问题描述 投票：0回答：7

假设我有一个数组，其中包含值 [1,2,3,6,7]。

如何检查数组是否包含 3 个连续的数字。例如，上面的数组包含 [1,2,3]，因此这将在我的函数中返回 false。

        var currentElement = null;
        var counter = 0;

        //check if the array contains 3 or more consecutive numbers:
        for (var i = 0; i < bookedAppArray.length; i++) {
            if ((bookedAppArray[i] != currentElement) && (bookedAppArray[i] === bookedAppArray[i - 1] + 1)) {

                if (counter > 2) {
                    return true;
                }

                currentElement = bookedAppArray[i];
                counter++;
            } else {
                counter = 1;
            }
        }

        if(counter > 2){
            return true;
        } else{
            return false;
        }
javascript jquery arrays
7个回答
7
投票

这个解决方案

  • 检查数组的长度是否大于
    2
    ,
  • 从位置 2 开始迭代数组
  • 获取索引之前位置2和1之间的差值，
  • 检查绝对差值是否为 
    1
  • 检查位置 1 之前和索引处之间的差异是否等于差异，
  • 如果是，则返回 false，因为找到了连续的元素。
  • 如果没有，则将索引增加 
    1

function consecutive(array) {
    var i = 2, d;
    while (i < array.length) {
        d = array[i - 1] - array[i - 2];
        if (Math.abs(d) === 1 && d === array[i] - array[i - 1]) {
            return false;
        }
        i++;
    }
    return true;
}

document.write(consecutive([1]) + '<br>');             // true
document.write(consecutive([2, 4, 6]) + '<br>');       // true
document.write(consecutive([9, 8, 7]) + '<br>');       // false
document.write(consecutive([1, 2, 3, 6, 7]) + '<br>'); // false
document.write(consecutive([1, 2, 3, 4, 5]) + '<br>'); // false

1
投票

我最近需要做同样的事情，并想出了这个功能，如果有人认为它有用的话。

assert(!Array.prototype.isConsecutive, 'Array.isConsecutive rewriting conflict');
/**
 * Check if array consist of consecutive numbers
 * @param {number} [startFrom] If array should start from a specific number
 * @returns {Boolean} true if array consist of consecutive numbers
 */
Array.prototype.isConsecutive = /** @lends Array */ function (startFrom) {
  let curVal;
  if (startFrom !== undefined) curVal = startFrom - 1;
  // eslint-disable-next-line no-return-assign
  return this.every((n) => (
    !Number.isNaN(n)
    && (curVal = (curVal === undefined ? n : curVal + 1))
    && n === curVal)) || false;
};

如果数组是连续的，则返回 

true
（这样更直观），如果需要反转，可以添加 
!
。 以下是一些测试：

  it('Array.isConsecutive', () => {
    expect([1, 2, 3, 4].isConsecutive()).to.be.true;
    expect([1, 2, 3, 4].isConsecutive(1)).to.be.true;
    expect([5, 6, 7, 8].isConsecutive()).to.be.true;
    expect([6, 5, 7, 8, 9].isConsecutive()).to.be.false;
    expect([1, 2, 3, 4].isConsecutive(2)).to.be.false;
  });

PS。我的示例中有一些 ani 模式（没有分配，没有原型内部函数）（我确信有些人会不喜欢我的答案），但我不在乎，如果你愿意，你可以将其转换为函数。

0
投票

从逻辑上思考，这应该像迭代数组一样简单，只需检查当前索引之前的两个索引即可。

只需将 

1
添加到前一个索引，并将 
2
添加到该索引之前的索引，它们应该都相等，就像这样

function hasThree(arr) {
    var res = false;

    arr.forEach(function(item, index) {
        var l1 = arr[index - 1], // get previous
            l2 = arr[index - 2]; // get the one before the previous

        if ( l1 && l2 ) { // if two previous exist

            // add 1, and then 2, and see if all are equal

            if ( item === l1 + 1 && item === l2 + 2 ) res = true;
        }
    });

    return res;
}

小提琴

0
投票

有趣的问题。 这是我的尝试。

function cons(ar) {

    var cnt = 0;

    ar.forEach(function (i, idx) {
        if (idx > 0) {
            if (i == (ar[idx - 1] + 1)){
                cnt++;
            }
            else {
                if (cnt < 2)
                    cnt = 0;
            }
        }
    });

    return cnt < 2;
}

console.log('expected true', cons([1, 2, 5, 6, 9]));
console.log('expected false', cons([0, 2, 3, 4, 6, 9]));
console.log('expected false', cons([1, 2, 3, 4, 6, 9]));
0
投票

这是一个。只需确保在执行之前对数组进行排序即可

function checkIfConsecutive(Arr) {
          let isCnsc = true;
          for (st in Arr ) {
               if ( Arr[parseInt(st)+1]-Arr[parseInt(st)] > 1 && !isNaN(Arr[parseInt(st)+1]-Arr[parseInt(st)] )) {
                    isCnsc = false;
               }
          }
           return isCnsc;
     }
0
投票

最初的方法可能是从输入数组中创建一个 Set ，以便排除重复的可能性，并且（排序后，如果相应的标志作为 

true
传递）只需检查最后一项是否减去第一项构成数组的当前长度：

console.log(isValid([1, 2, 3, 4])); // => true
console.log(isValid([1, 2, 4])); // => false
console.log(isValid([5, 6, 7])); // => true
console.log(isValid([5, 5, 6])); // => false
console.log(isValid([6, 5, 4], true)); // => true

function isValid(arr, doSort = false) {
  const uniqueSorted = [...new Set(arr)];
  
  if (doSort) uniqueSorted.sort((a, b) => a - b);
  
  const noDuplicates = uniqueSorted.length === arr.length;
  const noGaps = uniqueSorted[uniqueSorted.length - 1] - uniqueSorted[0] === uniqueSorted.length - 1;
  
  return noDuplicates && noGaps;
}

-1
投票

尝试使用 

Array.prototype.some()
, 
Array.prototype.filter()

var arr1 = [1, 2, 3, 9, 8, 7];
var arr2 = [1, 2, "a", 3];
var check = function(a) {
  // for each element in array `a` 
  return !a.some(function(item, index) { 
    // slice next three elements, including current element `item` from `a` array
    var next = a.slice(index, 3);
    console.log(next);
    // if next three items in array `a` are type `Number`
    // return `false`, else return `true`
    return next.filter(Number).length === 3 ? true : false
  })
};
// each item in `arr1` returns `false` , where item is followed
// by two numbers
// `arr2` returns `true` , where item is not followed by two numbers
console.log(check([1,2,3]), check(arr1), check(arr2)) // `false`, `false`, `true`

或者，使用 

for
循环，
Array.prototype.every()

var arr1 = [1, 2, 3, 9, 8, 7];
var arr2 = [1, 2, "a", 3];
var check = function(a) {
  var res;
  for (var i = 0; i < a.length; i++) {
    // if `a[i]` is followed by two numbers, return `false`
    if (a.slice(i, 3).every(function(n) {
      return typeof n === "number"
    })) {
      res = false;
      break;
    } 
    // if `a[i]` is not followed by two numbers, return `true`
    else {
      res = true;
      break;
    }
  }
  return res
}
console.log(check([1,2,3]), check(arr1), check(arr2)) // `false`, `false` , `true`

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.