Javascript 在一个数组中查找比另一个数组中的元素大的元素

有两个数组

data1

和

data2

。所需的结果是一个数组，其中包含

data1

中的所有元素，这些元素大于

data2

[+变量

缓冲区中定义的前3个元素]。换句话说，结果还应该包括匹配元素前面的
data1
中的前3个元素。两个数组都已按升序排序

我下面的代码实现了所需的功能，但是否有更好的方法来实现同样的功能？正则表达式会更快吗

数据集

data1 = [100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110]
data2 = [102, 104, 106, 108]
buffer = 3

期望的结果是
[106、107、108、109、110]

算法

largestData2 = _.max(data2)
data1LargerThanData2 = _.filter(data1, function(data1) {
    return data1 > largestData2
})
smallestData1LargerThanData2 = _.min(data1LargerThanData2)

sliceStart = data1.indexOf(smallestData1LargerThanData2) - buffer
result = data1.slice(sliceStart)

是否希望data1中的所有值都大于data2的最大值？如果是这样，这可能会有所帮助
您希望data1中的所有值都大于data2的最大值吗？如果是这样，这可能会有所帮助
您希望data1中的所有值都大于data2的最大值吗？如果是这样，这可能会有所帮助
您希望data1中的所有值都大于data2的最大值吗？如果是这样，这可能会有所帮助

var data1 = [100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110],
data2 = [102, 104, 106, 108];
var maxData2 = Math.max.apply(Math, data2);

var newData = [];
data1.map(function(val) {
    if(val > maxData2) {
        newData.push(val);
    }
});
var index = data1.indexOf(newData[0]); //getting index of 1st element

var prev3Arr = [data1[index-3], data1[index-2], data1[index-1]]; //forming prev 3 elements

var finalResult = $.merge( prev3Arr, newData); // merging both arrays

console.log(finalResult);

检查控制台的结果：
[106、107、108、109、110]

var data1 = [100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110],
data2 = [102, 104, 106, 108];
var maxData2 = Math.max.apply(Math, data2);

var newData = [];
data1.map(function(val) {
    if(val > maxData2) {
        newData.push(val);
    }
});
var index = data1.indexOf(newData[0]); //getting index of 1st element

var prev3Arr = [data1[index-3], data1[index-2], data1[index-1]]; //forming prev 3 elements

var finalResult = $.merge( prev3Arr, newData); // merging both arrays

console.log(finalResult);

检查控制台的结果：
[106、107、108、109、110]

var data1 = [100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110],
data2 = [102, 104, 106, 108];
var maxData2 = Math.max.apply(Math, data2);

var newData = [];
data1.map(function(val) {
    if(val > maxData2) {
        newData.push(val);
    }
});
var index = data1.indexOf(newData[0]); //getting index of 1st element

var prev3Arr = [data1[index-3], data1[index-2], data1[index-1]]; //forming prev 3 elements

var finalResult = $.merge( prev3Arr, newData); // merging both arrays

console.log(finalResult);

检查控制台的结果：
[106、107、108、109、110]

var data1 = [100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110],
data2 = [102, 104, 106, 108];
var maxData2 = Math.max.apply(Math, data2);

var newData = [];
data1.map(function(val) {
    if(val > maxData2) {
        newData.push(val);
    }
});
var index = data1.indexOf(newData[0]); //getting index of 1st element

var prev3Arr = [data1[index-3], data1[index-2], data1[index-1]]; //forming prev 3 elements

var finalResult = $.merge( prev3Arr, newData); // merging both arrays

console.log(finalResult);

检查控制台中的结果：
[106、107、108、109、110]
从获取数据2中的最大值开始：

var max = Math.max.apply(null, data2);

然后从
data1
中获取大于
max
的所有数字：

var arr = data1.filter(function (el) {
  return el > max;
});

使用
arr
中第一个值的值在
data1
中找到我们的起点，并从中获取适当的元素块

var index = data1.indexOf(arr[0]) - 3;
var chunk = data1.slice(index, index + 3);

将
arr
合并到
chunk
中

chunk.push.apply(chunk, arr); // chunk = [106, 107, 108, 109, 110]

.
从获取数据2中的最大值开始：

var max = Math.max.apply(null, data2);

然后从
data1
中获取大于
max
的所有数字：

var arr = data1.filter(function (el) {
  return el > max;
});

使用
arr
中第一个值的值在
data1
中找到我们的起点，并从中获取适当的元素块

var index = data1.indexOf(arr[0]) - 3;
var chunk = data1.slice(index, index + 3);

将
arr
合并到
chunk
中

chunk.push.apply(chunk, arr); // chunk = [106, 107, 108, 109, 110]

.
从获取数据2中的最大值开始：

var max = Math.max.apply(null, data2);

然后从
data1
中获取大于
max
的所有数字：

var arr = data1.filter(function (el) {
  return el > max;
});

使用
arr
中第一个值的值在
data1
中找到我们的起点，并从中获取适当的元素块

var index = data1.indexOf(arr[0]) - 3;
var chunk = data1.slice(index, index + 3);

将
arr
合并到
chunk
中

chunk.push.apply(chunk, arr); // chunk = [106, 107, 108, 109, 110]

.
从获取数据2中的最大值开始：

var max = Math.max.apply(null, data2);

然后从
data1
中获取大于
max
的所有数字：

var arr = data1.filter(function (el) {
  return el > max;
});

使用
arr
中第一个值的值在
data1
中找到我们的起点，并从中获取适当的元素块

var index = data1.indexOf(arr[0]) - 3;
var chunk = data1.slice(index, index + 3);

将
arr
合并到
chunk
中

chunk.push.apply(chunk, arr); // chunk = [106, 107, 108, 109, 110]

.
假设阵列始终有序：

var result;
var largestData2 = data2.slice( -1 );

_.each( data1, function( x, index ){
    if( x  > largestData2 ){
        result = data1.slice( index - buffer - 1 );
        return false;
    }
} );

假设阵列始终处于有序状态：

var result;
var largestData2 = data2.slice( -1 );

_.each( data1, function( x, index ){
    if( x  > largestData2 ){
        result = data1.slice( index - buffer - 1 );
        return false;
    }
} );

假设阵列始终处于有序状态：

var result;
var largestData2 = data2.slice( -1 );

_.each( data1, function( x, index ){
    if( x  > largestData2 ){
        result = data1.slice( index - buffer - 1 );
        return false;
    }
} );

假设阵列始终处于有序状态：

var result;
var largestData2 = data2.slice( -1 );

_.each( data1, function( x, index ){
    if( x  > largestData2 ){
        result = data1.slice( index - buffer - 1 );
        return false;
    }
} );

如果两个数组按升序排序，则可以省略
max
，只选择最后一个元素

var largestData2 = data2[data2.length - 1];

要查找
data1
中的位置大于
最大的\u data2
，可以使用二进制搜索，然后返回三个元素

var smallestData1LargerThanData2Index = binarySearch(data1, largestData2);
var sliceStart = smallestData1LargerThanData2Index - buffer;
if (sliceStart < 0)
    sliceStart = 0;

var result = data1.slice(sliceStart);

var smallestdata1largersandata2index=binarySearch（data1，largestData2）；
var sliceStart=smallestdata1largersandata2index-缓冲区；
如果（切片开始<0）
sliceStart=0；
var result=data1.slice（sliceStart）；


更新：

更新为实际使用。
如果两个数组按升序排序，您可以省略
max
，只选择最后一个元素

var largestData2 = data2[data2.length - 1];

要查找
data1
中的位置大于
最大的\u data2
，可以使用二进制搜索，然后返回三个元素

var smallestData1LargerThanData2Index = binarySearch(data1, largestData2);
var sliceStart = smallestData1LargerThanData2Index - buffer;
if (sliceStart < 0)
    sliceStart = 0;

var result = data1.slice(sliceStart);

var smallestdata1largersandata2index=binarySearch（data1，largestData2）；
var sliceStart=smallestdata1largersandata2index-缓冲区；
如果（切片开始<0）
sliceStart=0；
var result=data1.slice（sliceStart）；


更新：

更新为实际使用。
如果两个数组按升序排序，您可以省略
max
，只选择最后一个元素

var largestData2 = data2[data2.length - 1];

要查找
data1
中的位置大于
最大的\u data2
，可以使用二进制搜索，然后返回三个元素

var smallestData1LargerThanData2Index = binarySearch(data1, largestData2);
var sliceStart = smallestData1LargerThanData2Index - buffer;
if (sliceStart < 0)
    sliceStart = 0;

var result = data1.slice(sliceStart);

var smallestdata1largersandata2index=binarySearch（data1，largestData2）；
var sliceStart=smallestdata1largersandata2index-缓冲区；
如果（切片开始<0）
sliceStart=0；
var result=data1.slice（sliceStart）；


更新：

更新为实际使用。
如果两个数组按升序排序，您可以省略
max
，只选择最后一个元素

var largestData2 = data2[data2.length - 1];

要查找
data1
中的位置大于
最大的\u data2
，可以使用二进制搜索，然后返回三个元素

var smallestData1LargerThanData2Index = binarySearch(data1, largestData2);
var sliceStart = smallestData1LargerThanData2Index - buffer;
if (sliceStart < 0)
    sliceStart = 0;

var result = data1.slice(sliceStart);

var smallestdata1largersandata2index=binarySearch（data1，largestData2）；
var sliceStart=smallestdata1largersandata2index-缓冲区；
如果（切片开始<0）
sliceStart=0；
var result=data1.slice（sliceStart）；


更新：

更新为实际使用。
@KevinB我希望
data1
中的所有元素都大于
data2
中的任何元素，因此，我想我将在
data2
中查找最大的元素，以与
data1
@KevinB中的所有元素进行比较。我还希望包含
data1
中的3个其他元素，而不是前面的
[106107]
。对不起，我没有解释清楚，我有一个变量
buffer=3
whic