Javascript 如何使用不同的间隔过滤数字数组？

在下面的示例代码中，我想根据不同的间隔过滤数字阵列。区间由具有所述区间的下限和上限的2个数组的组合来定义。我如何识别匹配项或非匹配项，如下所示

const numbersArray = [1,2,3,4,5,6,7,8,9,10];
const lowerBound = [1, 4, 8];
const higherBound = [3, 6, 10];

如果代码有效，则以下测试应返回true：

matches == [2, 5, 9];
nonmatches == [1, 3, 4, 6, 7, 8, 10];
  

假设数组包含1000多个项目，并且数字不遵循任何模式。

下面是一个可读性较差但更现实的场景

let numbersArray = [];
let lowerBound = [];
let higherBound = [];

for (let i = 0; i< 1000; i++){
  numbersArray.push(i);
}

for(let i = 0; i < 100; i++) {
  lowerBound.push(i * 10);
  higherBound.push((i * 10) + Math.random() * 10);
}

let numbersArray=[]；
设lowerBound=[]；
设higherBound=[]；
for（设i=0；i<1000；i++）{
数字排列推送（i）；
}
for（设i=0；i<100；i++）{
下键推压（i*10）；
higherBound.push（（i*10）+Math.random（）*10）；
}

这就是你想要的吗

我正在使用reduce创建一个匹配数组，当这个数组匹配（在lowerBound和higherBound之间）时，我在其中放入一个新元素，对于非匹配，只需对numbersaray中不在匹配中的数字进行筛选

const numbersArray=[1,2,3,4,5,6,7,8,9,10]；
常量lowerBound=[1,4,8]；
常数higherBound=[3,6,10]；
常量匹配=下限。减少（（acc、val、i）=>{
返回[
…acc，
…NumberArray.filter（o=>！acc.includes（o）&&o>lowerBound[i]&&o！matches.includes（o））；
console.log（匹配项）；
控制台日志（不匹配）稍微调整了我的方法，以避免第二个过滤器循环。这只是针对
lowerBound
和
higherBound
的隐式对测试数组中的每个数字。您可以使用中的迭代变量非常简洁地实现这一点，前提是数组事先已正确格式化，并且没有松散的结尾


const numbersArray=[1,2,3,4,5,6,7,8,9,10]；
常量lowerBound=[1,4,8]；
常数higherBound=[3,6,10]；
让匹配项=[]；
设非匹配=[]；
numbersArray.forEach（num=>{
const matched=lowerBound.some（（绑定，i）=>{
返回num>bound&&num日志（匹配、非匹配）我想我应该先将下界值和上界值提取到一个谓词列表中，然后对数组中的每个数字进行迭代。根据是否匹配，它将进入匹配结果或非匹配结果


过滤函数（数组、下、上）{
常量谓词=lower.map（（v，i）=>（value）=>value>v&&value{
if（谓词.some（谓词=>谓词（cur）））{
agg[0]。推送（cur）；
}否则{
agg[1]。推送（cur）；
}
返回agg；
}, [[],[]]);
}
函数simpleTest（）{
常数数组=[1,2,3,4,5,6,7,8,9,10]；
常量lowerBound=[1,4,8]；
常数higherBound=[3,6,10]；
常量[匹配项，非匹配项]=已过滤（数字阵列、低位、高位）；
log（'matches'）；
console.log（匹配项）；
log（'matches'）；
控制台日志（不匹配）；
}
函数suggestest（）{
//与建议的测试
设numbersArray=[]；
设lowerBound=[]；
让higherBound=[]
for（设i=0；i<1000；i++）{
数字排列推送（i）；
}
对于（设i=0；i我将假设我们可以稍微更改数据结构，因为这样做很难处理：

const lowerBound=[1,4,8]；
常数higherBound=[3,6,10]；

如果相同索引中的元素要在一起，那么让我们这样做：

const-bound=[[1,3]、[4,6]、[8,10]；

稍后将转到
绑定

现在，让我们构建一个curried函数，用于验证
n
if
a
：

const-between=（a，b）=>n=>a

现在，让我们构建另一个curried函数，如果至少有一个函数返回
true
，则验证
n
：

const或=（…fns）=>n=>fns.some（fn=>fn（n））；
常数检查=或（x，y）；
检查（1）；//错误
检查（2）；//正确
检查（5）；//正确

在将每一对转换为between函数后，我们现在将
bound
转换为or函数：

const-bound=[[1,3]、[4,6]、[8,10]；
常量检查=或（…绑定.map（[a，b]）=>介于（a，b））之间；

check
现在是一个函数，如果
n
介于1和3之间或4和6之间，则该函数接受
n
并返回
true


const-between=（a，b）=>n=>an=>fns.some（fn=>fn（n））；
常数界=[[1,3]，[4,6]，[8,10]；
常量检查=或（…绑定.map（[a，b]）=>介于（a，b））之间；
常数[不匹配，匹配]=
[1,2,3,4,5,6,7,8,9,10]。减少(
（acc，n）=>
（acc[+检查（n）]。推动（n），acc），
[[], []]);
log（`match:[${match}]`）；
console.log（`no match:[${nomatch}]`）；
这种方法非常简单。首先，为了方便起见，将
低位
和
高位
压缩在一起（这是可选的）。然后，对于
数字阵列
中的每个
数字
，检查是否至少有一个匹配项（使用）介于下限和上限之间。将数字添加到“匹配”或“不匹配”数组中


const numbersArray=[1,2,3,4,5,6,7,8,9,10]；
常量lowerBound=[1,4,8]；
常数higherBound=[3,6,10]；
//将下限和上限压缩在一起
const bounds=lowerBound.map（（_，i）=>[lowerBound[i]，higherBound[i]]）；
const result={true:[]，false:[]}；
for（常数编号排列）{
常量匹配=边界。一些（[低，高]=>low
。是否执行此操作