9

假设我在 Javascript 中有一个整数数组，我想检查它的所有值是否都按升序排列。我想要的是将数组键保存在另一个数组中，以防算法发现一个较低（或相等）的值，不仅比较前一个值，而且比较它之前的任何值。我所做的是这样的：

arr = [], nonvalid = [];

for (var j = 1; j < arr.length; j++){
    if ( arr[j+1] <= arr[j] ){
        nonvalid.push(j);
    }
}

显然，上述算法仅检查与之前的值相比较低的值。

数组可能包含如下值：

arr = 1、2、3、10、5、11、12、2、4、25 _ _ _ _

无效值是粗体值。如果我运行上面的循环，它不会“捕捉”倒数第二个（4），因为它比它最接近的左兄弟高，但不比它所有的左兄弟高。

编辑：

尝试了以下解决方案，除了 mine 之外，没有返回此数组的所有无效值。:(

他们正确地返回了最后两个值，但没有返回第二个值。我不明白为什么。

[24398, 24397, 25004, 25177, 26302, 28036, 29312, 29635, 29829, 30476, 32595, 33732, 34995, 36047, 36363, 37310, 38022, 38882, 40746, 41212, 42846, 43588, 44029, 44595, 44846, 45727, 46041 ，47293，48002，48930，49858，51184，51560，51560，53895，54247，54614，55713，55713，56813，57282，57480 , 65940, 66203, 66572, 67957, 68796, 68964, 69098, 69233, 69435, 69759, 71496, 72577, 72823, 73007, 73252, 73743, 73866, 76405, 77037, 77416, 77669, 79691, 80885, 81339, 81794 , 82067, 82431, 83244, 84861, 86836, 88632, 89877, 90296, 91049, 91885, 92351, 92614, 93141, 93733, 93930, 94531, 95206, 95882, 96895, 97732, 97973, 99261, 99422, 99583, 100332 , 100599, 101666, 102066, 102600, 103504, 104432, 105174, 107216, 109085, 110181, 110679, 111177, 111988, 112553, 75,005, 11406, 600 ]

4

9 回答 9

9

跟踪您看到的最大值（参见小提琴）：

function find_invalid_numbers(arr) {
    var nonvalid, i, max;

    nonvalid = [];

    if (arr.length !== 0) {
        max = arr[0];

        for (i = 1; i < arr.length; ++i) {
            if (arr[i] < max) {
                nonvalid.push(arr[i]);
            } else {
                max = arr[i];
            }
        }
    }

    return nonvalid;
}
于 2013-04-29T19:15:42.880 回答
9

另一种非常好的功能方式可能是；

var isAscending = a => a.slice(1)
                        .map((e,i) => e > a[i])
                        .every(x => x);
                        
console.log(isAscending([1,2,3,4]));
console.log(isAscending([1,2,5,4]));

不错的代码，但其中有冗余。我们可以通过合并.map()和.every()合而为一来进一步简化。

var isAscending = a => a.slice(1)
                        .every((e,i) => e > a[i]);
                        
console.log(isAscending([1,2,3,4]));
console.log(isAscending([1,2,5,4]));

于 2017-10-08T23:30:16.797 回答
4

为什么不与最后一个已知的好数字比较呢？

var arr = [1, 2, 3, 10, 5, 11, 12, 2, 4, 25],
    nonvalid = [],
    lastGoodValue = 0;

for (var j = 1; j < arr.length; j++) {
    if (j && arr[j] <= lastGoodValue) {
        //if not the first number and is less than the last good value
        nonvalid.push(arr[j]);
    } else {
        //if first number or a good value
        lastGoodValue = arr[j];
    }
}

console.log(arr, nonvalid)
于 2013-04-29T19:16:57.093 回答
4

当你发现一个元素乱序时，查看下一个元素，直到它们相对于乱序元素之前的元素不再乱序。

将乱序元素添加到第二个数组并从新的有序元素继续。

var outs= [], L= A.length, i= 0, prev;
while(i<L){
    prev= A[i]; 
    while(A[++i]<prev) outs.push(i);
}
alert(outs)
于 2013-04-29T20:06:17.063 回答
1

一种简单的函数式方法，可以在没有循环或变量的情况下内联：

arr.filter(function(a,b,c){
  return  Math.max.apply(Math, c.slice(0,b)) > a ;
});
于 2013-04-29T20:38:47.447 回答
1

DEMO

var arr = [24398, 24397, 25004, 25177, 26302, 28036, 29312, 29635, 29829, 30476, 32595, 33732, 34995, 36047, 36363, 37310, 38022, 38882, 40746, 41212, 42846, 43588, 44029, 44595, 44846, 45727, 46041, 47293, 48002, 48930, 49858, 51184, 51560, 53895, 54247, 54614, 55713, 56813, 57282, 57480, 57875, 58073, 58403, 60321, 61469, 62051, 62310, 62634, 63217, 64505, 65413, 65677, 65940, 66203, 66572, 67957, 68796, 68964, 69098, 69233, 69435, 69759, 71496, 72577, 72823, 73007, 73252, 73743, 73866, 76405, 77037, 77416, 77669, 79691, 80885, 81339, 81794, 82067, 82431, 83244, 84861, 86836, 88632, 89877, 90296, 91049, 91885, 92351, 92614, 93141, 93733, 93930, 94531, 95206, 95882, 96895, 97732, 97973, 99261, 99422, 99583, 100332, 100599, 101666, 102066, 102600, 103504, 104432, 105174, 107216, 109085, 110181, 110679, 111177, 111988, 112553, 113005, 113457, 600, 600],
    nonvalid = [],
    max = arr[0];

for(var j=0; j<arr.length; j++){
    var test= arr[j+1]<=max ? nonvalid.push(arr[j+1]) : max=arr[j];
}

alert(nonvalid); // 24397, 600, 600
于 2013-04-29T19:50:10.547 回答
1

您可以使用map此示例：

const ascendingArray = [1,2,3,4,5,6,7];
const descendingArray = [1,2,3,7,5,6,4]

const isAscending = array => array.map((a, i) => a > array[i + 1]).indexOf(true) === -1

console.log(isAscending(descendingArray)); // should be false
console.log(isAscending(ascendingArray)); // should be true

或者，您可以filter在此示例中使用：

const ascendingArray = [1,2,3,4,5,6,7];
const descendingArray = [1,2,3,7,5,6,4]

const isAscending = array => array.filter((a, i) => a > array[i + 1]).length === 0;

console.log(isAscending(ascendingArray)); // should be true
console.log(isAscending(descendingArray)); // should be false

于 2021-01-03T05:36:32.660 回答
0

首先复制数组，删除任何与 不按顺序的元素array.splice(index, 1)，然后继续。这样，任何元素都必须大于它之前的那个，但它之前的那个永远是最大值。

于 2013-04-29T19:14:52.310 回答
0

在听取您的建议后回答我自己的问题，我尝试了以下算法。它似乎完成了它的工作，但它有点矫枉过正。

for (var i = 0; i < arr.length; i++){

for (var j = 1; j < arr.length; j++){

    if ( arr[j] > 0 && arr[i] > 0 && j != i ){

        if ( arr[j] <= arr[i] && j > i ){

            if ( jQuery.inArray(j, nonvalid) == - 1) nonvalid.push(j);
        }
    }
} }
于 2013-04-29T19:22:34.633 回答