Javascript 如何匹配两个整数数组，使最小的数组从较大的数组扩展到最近的相邻数组

假设我有两个数组对：

let a1 = [2000, 4000, 6000, 8000, 10000, 12000],
    b1 = [2000, 4000, 6000, 8000, 10000, 12000, 14000];

及

或任意一对整数

任务是以这种方式将对中最小的数组扩展到最大大小，使最小的域和值保持相同：

b1 =          [2000, 4000, 6000, 8000, 10000, 12000, 14000];
expanded_a1 = [2000, 4000, 6000, 8000, 10000, 12000, 12000];

a2 =          [10000, 15000, 20000, 25000, 30000, 35000, 40000, 45000, 50000, 55000]
expanded_b2 = [10000, 20000, 20000, 30000, 30000, 40000, 40000, 50000, 50000, 60000];

invalid_expanded_b2 = [10000, 15000, 20000, 30000, 30000, 40000, 40000, 50000, 50000, 60000];

//second value is invalid

再一次，第三对的例子：

let a3 = [10, 15, 20, 25, 30, 35];
let b3 = [10, 20, 30];

因此，扩展b3应该只有10,20,30个值，其域必须是[10,30]

              [10, 15, 20, 25, 30, 35]
                ↓   ↓   ↓   ↓   ↓   ↓
expanded_b3 = [10, 20, 20, 30, 30, 30]

---

非常确定，首先，我需要克隆最大的数组，遍历它的每个元素，并将其与最小数组中的整数进行比较，如果值不匹配，则将其替换为最小数组中最接近的左整数（或者如果没有，则为右整数）

不确定，但类似于这种笨拙的解决方案

Number.prototype.between=函数（域）{
var min=Math.min.apply（数学，域）；
var max=Math.max.apply（数学，域）；
返回此>=最小值和此长度（&b）{
如果（a_.length-b_.length==1）{b_.push（b_[b_.length-1]），返回[a_，b_]}
设b2=a_u.切片（0，a_u.长度）；
b2.forEach（（d_uu，i_u）=>{
for（设i=1；ib_u[b_u.length-1]）{b2[i_z]=b_u[b_u.length-1]}
}
});
返回[a，b2]
}
否则{
如果（b_.length-a_.length==1）{a_.push（a_[a_.length-1]），返回[a_，b_]}
设a2=b_u.切片（0，b_u.长度）；
a2.forEach（（d_uu，i_u）=>{
for（设i=1；ia_u[a_u.length-1]）{a2[i_z]=a_u[a_u.length-1]}
});
返回[a2，b_]
}
}

这一点一开始似乎很难做到，但实际上并没有那么难。您只需同时检查两个阵列。将其视为获取两个指针，然后移动它们：

a2=[10000,15000,20000]
^^^^^
|
指针1----
b2=[10000，20000]
^^^^^
|
指针2--

• 如果分配给每个指针的当前值相等，则有一个匹配项-只需返回值并移动两个指针即可

a2=[10000,15000,20000]
^^^^^
|
指针1-----------
b2=[10000，20000]
^^^^^
|
指针2--------

• 如果当前值不匹配，则只前进属于较长数组的指针，但从较短数组返回值

a2=[10000,15000,20000]
^^^^^
|
指针1------------------
b2=[10000，20000]
^^^^^
|
指针2--------

重复此操作，直到完成较长的阵列

您可以在

O（n）

时间内完成此操作

下面是一个使用a和ES6阵列来遍历这两个阵列的实现。它比使用指针稍微方便一些，因为您可以使用

设a1=[2000400060008001000012000]，
b1=[2000,4000,6000,8000,10000,12000,14000]；
设a2=[10000,15000,20000,25000,30000,35000,40000,45000,50000,55000]，
b2=[10000,20000,30000,40000,50000,60000]；
功能均衡长度（arr1、arr2）{
//长度相等，无需操作，只需返回即可
if（arr1.length==arr2.length）返回；
//设置要使用的内容
让我们长途跋涉；
让我们扩展；
如果（arr1.length>arr2.length）{
长阵列=arr1；
arrayToExpand=arr2；
}否则{
长阵列=arr2；
arrayToExpand=arr1；
}
const generator=生成发射插槽（阵列展开，长阵列）；
//转换为数组
const result=Array.from（生成器）；
返回结果；
}
功能*生成新插槽（短、长）{
//为每个数组启动两个迭代器
const shortIterator=shorter[Symbol.iterator]（）；
常量longIterator=longer[Symbol.iterator]（）；
//获取初始值
设shortCurrent=shortIterator.next（）；
设longCurrent=longIterator.next（）；
设lastShortValue=shortCurrent.value；
//两种方法都进行，直到较长的方法都用尽
而（！longCurrent.done）{
//生成较短数组的当前值
产量价值；
//仅当两个迭代器“赶上”时，才推进短迭代器
if（shortCurrent.value==longCurrent.value）{
shortCurrent=shortIterator.next（）；
//除非迭代器耗尽，否则更新该值
//在'short=[a，b]`和'long=[a，b，c]`的情况下，这将为最后的值生成'undefined'
如果（！shortCurrent.done）{
lastShortValue=shortCurrent.value
}
}
//始终推进长迭代器
longCurrent=longIterator.next（）；
}
}
扩展_a1=相等长度（a1，b1）；
控制台日志（扩展的_a1）；
扩展_b2=相等长度（a2，b2）；
console.log（扩展的_b2）这通常称为插值-当您知道值
a
和值
c
但需要找到介于两者之间的值
b
。特别是当你有一个单调的序列或者可以为丢失的数据创建一些推理规则时。我找不到什么
              [10, 15, 20, 25, 30, 35]
                ↓   ↓   ↓   ↓   ↓   ↓
expanded_b3 = [10, 20, 20, 30, 30, 30]