使用for循環或switch語句的JavaScript序列

Question

我遇到問題以及如何解決它。請注意，我對JavaScript相對來說比較陌生，這個問題讓我覺得自己過於複雜了。

問題：

鑑於整數作爲陣列的序列，判定是否有可能通過不超過一個元件從陣列中除去，以獲得嚴格遞增順序。

例

對於序列= [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

考慮到帕特里克·巴爾的建議，並假設ES6和箭頭的功能都很好，該解決方案使用Array.prototype.filter可以工作。過濾器本身將返回應該被移除以滿足問題的條件的元素的數組：

修訂

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

讓退一步和思考問題： 「給定一個整數序列作爲一個數組」 - 我們正在處理數據數組......但你已經知道了。

「確定是否有可能獲得嚴格增加的序列」好吧，我們需要做一些檢查有效序列的東西。

「通過從陣列中刪除不超過一個元素」。所以我們可以嘗試逐個採集每個元素，並且如果至少有一個結果數組是連續的，那麼可能的話。

現在不是一個大問題，我們有兩個較小的

首先，我們正在處理的陣列，所以利用自己的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} 
    }); 
} 

它需要一個輸入陣列，並且使用稱爲每（）陣列內置函數，運行在每個元件上的測試中，如果所有的數組 ，並返回「真」元素測試正確。我們的測試預計，對於任何給定元素，第一個元素始終低於第二個元素要比前一個元素大，並且小於下一個元素，最後一個元素要大於倒數第二個元素 （如果有的話）元素不滿足這個測試，整個事情返回false 現在我們有一個看到一個數組是順序的手段，這將使下一個部分更容易

現在我們做另一個功能，拔出個別元素，並看到如果anythign作品

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

我們首先做一個數組每次嘗試的結果存儲到數組「結果」，我們的Wi稍後再使用它。 然後，我們提供一個提供的數組'input'並使用「forEach（）」，它對數組中的每個元素執行一個函數。對於每個元素，我們創建一個新數組，並從中刪除該元素，然後運行我們之前創建的「checkSequence（）」函數，最後將結果存儲在results數組中。

當在foreach完成後，我們把結果陣列並在其上使用「一些（）」，它的工作原理就像「每（）」 只有它，如果至少一個值是true，則返回true

現在，您只需調用isPossible（your_array），它將滿足問題