Question

我遇到问题以及如何解决问题。请注意，我对JavaScript相对较新，而且问题就像我过度复杂化一样。

问题：

给定一个整数序列作为数组，通过从数组中删除不超过一个元素来确定是否可以获得严格增加的序列。

实施例

对于sequence = [1, 3, 2, 1]，输出应为 almostIncreasingSequence(sequence) = false;

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

对于sequence = [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]。

从问题描述中，不清楚天气程序必须删除一个字符。但如果是这种情况，下面的代码应该这样做。

＆＃13;

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));

＆＃13;

Answer 2

考虑到Patrick Barr的建议并假设es6和箭头功能正常，使用Array.prototype.filter的此解决方案可以正常工作。过滤器本身将返回应删除的元素数组，以满足问题的条件：

<强>已更新

＆＃13;

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

＆＃13;

Answer 3

让我们退一步思考问题：＆＃34;给定一系列整数作为数组＆＃34; - 我们正在处理数据数组......但你已经知道了。

＆＃34;确定是否有可能获得严格增加的序列＆＃34;好的，我们需要做一些检查有效序列的东西。

＆＃34;从数组中删除不超过一个元素。＆＃34;所以我们可以尝试逐个采摘每个元素，如果至少有一个结果数组是连续的，那么它是可能的。

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

首先，我们正在处理数组，因此您可以使用JavaScript的内置数组函数来简化操作。在下面，我们使用＆＃39; every（）＆＃39;，＆＃39; forEach（）＆＃39;，＆＃39; splice（）＆＃39;，＆＃39; push（）＆＃39;和＆＃39; some（）＆＃39;你可以在这里了解它们是如何运作的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（）的Array内置函数，它对数组中的每个元素运行一个测试并返回＆＃39; true＆＃39;如果所有元素都测试为真。我们的测试期望第一个元素总是低于第二个元素对于任何给定元素要大于前一个元素，小于下一个元素，并且最后一个元素要大于倒数第二个元素如果任何元素不满足此测试，则整个事件返回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});
}

我们首先制作一个数组，将每次尝试的结果存储到数组＆＃39;结果＆＃39;我们稍后会用它。然后，我们采用提供的阵列输入＆＃39;并使用＆＃34; forEach（）＆＃34;，它对数组中的每个元素执行一个函数。对于每个元素，我们创建一个新元素，并从中删除该元素，然后运行＆＃34; checkSequence（）＆＃34; 我们之前做过的函数，最后将结果存储在结果数组中。

当forEach完成后，我们获取结果数组并使用＆＃39; some（）＆＃39;在它上面，就像每个（）＆＃39; 只有当至少有一个值为真时才返回true

现在，您只需调用isPossible（your_array）即可解决问题

使用for循环或switch语句

3 个答案: