JavaScript 使用 for 循环或 switch 语句的序列

Question

我遇到了一个问题以及如何解决它。请注意，我是 JavaScript 的新手，我觉得这个问题过于复杂了。

问题：

Given a sequence of integers as an array, determine whether it is possible to obtain a strictly increasing sequence by removing no more than one element from the array.

例子

对于序列=[1, 3, 2, 1]，输出应该是 almostIncreasingSequence(sequence) = false;

此数组中没有一个元素可以删除以获得严格递增的序列。

对于序列=[1, 3, 2]，输出应该是 almostIncreasingSequence(sequence) = true.

您可以从数组中删除 3 以获得严格递增序列 [1, 2]。或者，您可以删除 2 以获得严格递增序列 [1, 3].

感谢您的所有评论！我想将其更新为一个更好的问题，并通知您我已经找到了解决方案，如果有人想检查它并查看是否有更简洁的方式来放置它。 :)

function almostIncreasingSequence(sequence) {    
  if(sequence.length == 2) return true;
  var error = 0;
  for(var i = 0; i < sequence.length - 1; i++){
    if(sequence[i] >= sequence[i+1]){
      var noStepBack = sequence[i-1] && sequence[i-1] >= sequence[i+1];
      var noStepFoward = sequence[i+2] && sequence[i] >= sequence[i+2];
      if(i > 0 && noStepBack && noStepFoward) {
        error+=2;
      }else{
        error++;
      }
    }
    if(error > 1){
      return false;
    }
  }
  return true;
}

Answer 1

想想你的代码：

sequence[i+1] - sequence[i] !== 1, variable++;

适用于以下数组：[1,2,3,8,8]。

从问题描述来看，不清楚程序必须删除一个字符。但如果是这样的话，下面的代码应该可以做到。

function canGetStrictlyIncreasingSeq(numbers) {
  var counter = 0;
  var lastGreatestNumber = numbers[0];
  for (var i = 1; i < numbers.length; i++) {
    if (lastGreatestNumber >= numbers[i]) {
      counter++;
      lastGreatestNumber = numbers[i];
    } else {
      lastGreatestNumber = numbers[i];
    }
  }
  if (counter <= 1)
    return true;
  return false;
}

var nums1 = [1, 2, 3, 4, 5]; //true
var nums2 = [1, 2, 2, 3, 4]; //true
var nums3 = [1, 3, 8, 1, 9]; //true
var nums4 = [3, 2, 5, 6, 9]; //true
var nums5 = [3, 2, 1, 0, 5]; //false
var nums6 = [1, 2, 2, 2, 3]; //false
var nums7 = [1, 1, 1, 1, 1]; //false
var nums8 = [1, 2]; //true
var nums9 = [1, 2, 2]; //true
var nums10 = [1, 1, 2, 3, 4, 5, 5]; //false
var nums11 = [10, 1, 2, 3, 4, 5]; //true
var nums12 = [1, 2, 3, 4, 99, 5, 6]; //true


console.log(canGetStrictlyIncreasingSeq(nums1));
console.log(canGetStrictlyIncreasingSeq(nums2));
console.log(canGetStrictlyIncreasingSeq(nums3));
console.log(canGetStrictlyIncreasingSeq(nums4));
console.log(canGetStrictlyIncreasingSeq(nums5));
console.log(canGetStrictlyIncreasingSeq(nums6));
console.log(canGetStrictlyIncreasingSeq(nums7));
console.log(canGetStrictlyIncreasingSeq(nums8));
console.log(canGetStrictlyIncreasingSeq(nums9));
console.log(canGetStrictlyIncreasingSeq(nums10));
console.log(canGetStrictlyIncreasingSeq(nums11));
console.log(canGetStrictlyIncreasingSeq(nums12));

Answer 2

考虑到 Patrick Barr 的建议并假设 es6 和箭头函数没问题，这个使用 Array.prototype.filter 的解决方案可以工作。过滤器本身将 return 元素数组，应删除这些元素以满足问题的条件：

已更新

function isSequential(array) {
    return array && array.length > 0 ? array.filter((x,i) => x >= array[i + 1] || array[i + 1] <= array[i - 1]).length < 2 : false;
}


console.log(isSequential([1]));
console.log(isSequential([1,2,4,5,6]));
console.log(isSequential([1,2,2,3,4,5,6]));
console.log(isSequential([1,4,3,2,5,6]));
console.log(isSequential([1,2,3,4,5,6]));
console.log(isSequential([1,2,0,3,4]));
console.log(isSequential([1,1]));
console.log(isSequential([1,2,0,1,2]));
console.log(isSequential([1,2,3,1,2,3]));
console.log(isSequential([]));
console.log(isSequential([1,0,0,1]));
console.log(isSequential([1,2,6,3,4])); //should be true, but return false

Answer 3

让我们退后一步思考问题："Given a sequence of Integers as an array" - 我们正在处理数据数组...但您已经知道了。

"determine whether it is possible to obtain a strictly increasing sequence" 好的，我们需要做一些检查有效序列的东西。

"by removing no more than one element from the array." 所以我们可以尝试一个一个地提取每个元素，如果至少一个结果数组是顺序的，它是可能的。

现在我们有两个小问题而不是一个大问题

首先，我们要处理数组，因此请利用 JavaScript 的内置数组函数让事情变得更简单。在下面，我们使用 'every()'、'forEach()'、'splice()'、'push()' 和 'some()' 你可以在这里阅读它们的工作原理 https://www.w3schools.com/jsref/jsref_obj_array.asp 这是时间不长，值得您花时间。

让我们来处理第一个问题：判断一个数组是否是连续的。下面的函数就是这样做的

function checkSequence(inputArray){
    return inputArray.every(function(value, index, arr){
        if (index == 0  && value < arr[index + 1]) {return true}
        else if (index < arr.length  && value < arr[index + 1] && value > arr[index - 1]) {return true}
        else if (index = arr.length - 1 && value > arr[index - 1]) {return true}
        else {return false}
    });
}

它接受一个输入数组，并使用一个名为 every() 的数组内置函数，该函数运行对数组中的每个元素进行测试 returns 'true' 如果所有元素都测试为真。我们的测试期望第一个元素总是低于第二个对于任何给定的元素大于前一个元素，小于下一个元素，并且最后一个元素大于倒数第二个元素如果任何元素不满足这个测试，整个事情 returns false 现在我们有一种方法可以看出数组是顺序的，这将使下一部分更容易

现在我们创建另一个函数来提取单个元素并查看是否有任何效果

function isPossible(input){
    var results = []; //we will store our future results here
    input.forEach(function(value, index, arr){
        copy = Array.from(arr); //we work on a copy of 'arr' to avoid messing it up (splice mangles what you give it, and we need the un-maimed version for later iterations)
        copy.splice(index, 1); //remove an element from copy (a copy of 'arr')      
        results.push(checkSequence(copy)); //see if it is still in sequence
    });
    return results.some(function(value){return value});
}

我们先做一个数组，将每次尝试的结果存储到数组中'results'我们后面会用到。然后，我们采用提供的数组 'input' 并使用 "forEach()"，它对数组中的每个元素执行一个函数。对于每个元素，我们创建一个新数组，并从中删除该元素，然后我们运行 "checkSequence()" 我们之前在上面做的函数，最后将结果存入results数组。

forEach 完成后，我们获取结果数组并在其上使用 'some()'，其工作方式与 'every()' 相同仅当至少有一个值为真时 returns 才为真

现在，您只需调用 isPossible(your_array) 即可满足问题

JavaScript 使用 for 循环或 switch 语句的序列

JavaScript sequence using for loop or switch statement

javascript

arrays

sequences