Javascript 基于元素'合并两个数组；s数字顺序

我试图找到解析数组的算法。它应该做什么：在输入时，它需要两个数组

第一个数组=[[10,25]，[30,45]，[50,60]

和

第二个数组=[35,40]

在输出时，它应该返回一个数组

[[10,25]，[30,35]，[40,45]，[50,60]]

。正如您所猜测的，它需要

第二个数组[1]

并与

第一个数组[each][1]

进行比较，然后创建子数组。到目前为止，我得到了（代码如下）。在if语句中，我需要返回两个。第二个参数也可以是多个数组。

/*——问题的第一部分----*/
常量first_数组=[[10,25]、[30,45]、[50,60]；
const second_数组=[35,40]；
const result=first_array.map（记录=>{
if（第二个数组[0]>记录[0]&第二个数组[0]<记录[1]）{
返回[[record[0]，second_array[0]]，[second_array[1]，record[1]]
}否则{
返回记录
}
});
console.log（结果）
//结果[[10,25]，[30,35]，[40,45]，[50,60]]
//期望[[10,25]、[30,35]、[40,45]、[50,60]]
/*----问题的第二部分----*/
常量first_数组=[15,60]；
const second_数组=[[25,30]，[30,40]，[45,55]；
// [[15, 60]]
// [[15, 25], [30, 60]]
// [[15, 25], [30, 30], [40, 60]]
//输出//[[15,25]，[30,30]，[40,45]，[55,60]

首先我加入数组，然后对数组进行排序和拆分

var a=[[10,25], [30,45], [50,60]]
var b=[35, 40];

var sorted=[].concat.apply([], a,b).sort();

var pairs = [];

for(var i = 0; i < sorted.length; i += 2)
{
    pairs.push(sorted.slice(i, i + 2));
}

var a=[[10,25]、[30,45]、[50,60]]
VarB=[35,40]；
var sorted=[].concat.apply（[]，a，b）.sort（）；
var对=[]；
对于（变量i=0；i

使用

reduce

而不是

map

const first_array=[[10,25], [30,45], [50,60]];
const second_array=[35, 40];

const result = first_array.reduce((a, record) => {
  if (second_array[0] > record[0] && second_array[0] < record[1]) {
    a.push([record[0], second_array[0]])
    a.push([second_array[1], record[1]])
  } else {
    a.push(record)
  }

  return a
}, [])

console.log(result)

const first_数组=[[10,25]、[30,45]、[50,60]；
const second_数组=[35,40]；
const result=第一个数组。reduce（（a，记录）=>{
if（第二个数组[0]>记录[0]&第二个数组[0]<记录[1]）{
a、 推送（[记录[0]，第二个数组[0]]）
a、 推送（[第二个数组[1]，记录[1]]）
}否则{
a、 推送（记录）
}
归还
}, [])
console.log（结果）

可以对数组使用一个生成器，对嵌套数组使用相同的生成器

然后检查值是否有序，并通过检查收集器数组的长度来更新结果数组

继续操作，直到两台发电机返回完成

函数组合（leftArray，rightArray）{
函数*getElements（数组）{
var i=0；
while（i
.as控制台包装器{max height:100%！important；top:0；}
这里有一个有趣的方法，我希望它很快

我们有一个数组扫描功能，它的工作原理类似于地图。接受一个函数，该函数在更新处于关闭状态的累加器时修改每个元素。我们在这里使用的功能是一个分拣机，它需要调整2个阵列的大小，并在其中一个阵列中订购最小的项目，在另一个阵列中订购其余的项目。因此，
分拣机（[1,5]，[3,7]）
将产生
[1,3]
，收集器将变为
[5,7]
。在这里


var first_数组=[[10,25]、[30,45]、[50,60]，
第二个_数组=[28,46]，
合并=（a，f，t）=>a.map（（t=>e=>f（e，t））（t））.concat（[t]），
分拣机=（a，b）=>a[1]b[1]？（[a[0]，b[0]]=[b[0]，a[0]]，[a[1]，b[1]]=[b[1]，a[1]]，a）
：a[0]>b[0]？（[a[0]，b[1]=[b[1]，a[0]]，[a[0]，b[0]]=[b[0]，a[0]]，[a[1]，b[1]=[b[1]，a[1]]，a）
：（[a[1]，b[0]]=[b[0]，a[1]]，b.reverse（），a），
结果=合并（第一个\u阵列、分拣机、第二个\u阵列）；
log（JSON.stringify（result））
如果递增数字的总数是奇数怎么办？@bigless这不是奇数或事件，我需要数组（子数组，子数组，子数组）而不是数组（子数组，子数组，子数组）我看到了对，所以我只是问
[[10,25]，[30,45]，[50,60]
和
[30,40]
[[10,25]，[30,30]、[40,45]、[50,60]]
输入数组是否总是预先排序？如果要对数字进行排序，必须添加一个callback@RamzanChasygov，请在问题中添加其他用例。实际上，第二个数组似乎没有嵌套。
[1515930300000，1515956400000]，[1515907020000，1515920400000]
with
[151596000000，151596000000]
返回
[151596000000，1515930300000]，[1515956400000，15159070200000]，[1515920400000，151596000000]
应返回
[151596000000，151597020000]，[1515920400000，1515930300000]，[1515956400000，151596000000]
但与Generator的接触很好阵列未排序。这是规格的变化吗？