Javascript 如何合并间距数组

存在一系列间隔，有必要组合重叠，即：

[[0, 33], [66, 80]] => [[0, 33], [66, 80]]

[[0, 33], [66, 80], [0, 66], [33, 100]] => [0,100]

编写代码。我得到了结果 [[0, 100], [66, 80]]. 这是因为首先是范围 [0,33]]，然后 [[0, 33], [66, 80]] 那么 [[0, 66], [66, 80]] 那么 [[0,100]，[66,80]]好像在不循环的情况下检查其他范围

const data = [
    [0, 33],
    [66, 80],
    [0, 66],
    [33, 100]
  ];

  createDataForSlider = data =>
    data.reduce((prevVal, time) => {
      let isPrevValUpdated = false;

      const timeStart = time[0];
      const timeEnd = time[1];

      /* eslint no-param-reassign: ["error", { "ignorePropertyModificationsFor": ["prevVal"] }] */
      if (prevVal.length) {
        for (let i = 0, ii = prevVal.length; i < ii; i += 1) {
          let prevValCurrent = prevVal[i];

          if (timeStart >= prevValCurrent[0] && timeEnd <= prevValCurrent[1]) {
            isPrevValUpdated = true;
            break;
          }
          if (
            !isPrevValUpdated &&
            timeStart >= prevValCurrent[0] &&
            timeStart <= prevValCurrent[1]
          ) {
            prevValCurrent[1] = timeEnd;
            isPrevValUpdated = true;
            break;
          }
          if (
            !isPrevValUpdated &&
            timeEnd >= prevValCurrent[0] &&
            timeEnd <= prevValCurrent[1]
          ) {
            prevValCurrent[0] = timeStart;
            isPrevValUpdated = true;
            break;
          }

          //console.log("prevVal-", prevVal);
        }
      }
      if (!isPrevValUpdated) {
        prevVal.push([timeStart, timeEnd]);
      }
      return prevVal;
    }, []);

  createDataForSlider(data);

const数据=[
[0, 33],
[66, 80],
[0, 66],
[33, 100]
];
createDataForSlider=数据=>
数据减少（（prevVal，time）=>{
让isprevValueUpdated=false；
const timeStart=时间[0]；
const timeEnd=时间[1]；
/*eslint无参数重新分配：[“错误”，{“ignorePropertyModificationsFor”：[“prevVal”]}]*/
if（前值长度）{
对于（设i=0，ii=prevVal.length；i=prevValCurrent[0]&&timeEnd=prevValCurrent[0]&&
timeStart=prevValCurrent[0]&&
timeEnd一次又一次地循环，直到输出数组的长度等于输入数组的长度

如果在一轮之后有重叠，下一轮将合并这两个，输出将更短

进程将在少于data.lenght步数的时间内停止

从运行时间的角度来看，这不是最有效的方法，但如果这不是一个问题，我会选择它。
试试下面的方法

根据所有开始时间对数组进行排序
现在，通过比较先前插入的频率和当前频率，使用空数组累加器来减少它

const frequencies = [[0, 33], [66, 80], [0, 66], [33, 100]];

const sortedFrequencies = frequencies.sort((f1, f2) =>{ return f1[0] - f2[0]});

sortedFrequencies.reduce((acc, current) => {
   if(acc.length > 0 && current[0] <= acc[acc.length - 1][1]) {

        acc[acc.length - 1][1] = current[1] > acc[acc.length - 1][1] ? current[1] : acc[acc.length - 1][1];
   } else {

        acc.push(current)
   }
   return acc;
}, []);

const frequencies=[[0,33]、[66,80]、[0,66]、[33,100]；
const sortedFrequencies=frequencs.sort（（f1，f2）=>{return f1[0]-f2[0]}）；
分拣频率减少（（acc，电流）=>{
如果（acc.length>0和当前[0]acc[acc.length-1][1]？当前[1]：acc[acc.length-1][1]；
}否则{
附件推送（当前）
}
返回acc；
}, []);

您需要先按如下方式对输入数组进行排序：

data.sort((val1, val2) => {
  //order by range start ASC
  let res1 = val1[0] - val2[0];

  if (res1 === 0) {
    //order by range end DESC
    return val2[1] - val1[1];
  }

  return res1;
});

然后它应该可以工作。
您可以对数组进行排序（开始ASC、结束DESC），检查开始和结束位置是否在另一个数据集的范围内，然后返回一个包含最小值和最大值的新集合。否则，取原始值


函数合并（数组）{
返回数组
.sort（（a，b）=>a[0]-b[0]| | b[1]-a[1]）
.减少（（t[l，r]）=>{
var项目=[[l，r]]；
如果（！t）返回[[l，r]]；
返回t
.map（[a，b]）=>
l若要合并重叠的一维数组，.sort（）将根据元素0处的每个一维数组的升序值对二维数组进行排序。然后，您可以循环遍历已排序二维数组的每个元素-1，并检查索引i处的元素是否是索引i+1处元素的子集。如果是，请将索引i+1处的元素推送到新数组

function isSubSet(a, b) {
    if ((a[0] >= b[0] && a[1] <= b[1]) ||
        (a[0] <= b[0] && a[1] >= b[1])) {
        return true;
    } else {
        return false;
    }
}

function mergeArray(arr) {

    let newArr = [];

    for (let i = 0; i < arr.length - 1; i++) {
        if (isSubSet(arr[i], arr[i + 1])) {
            newArr.push(arr[i + 1]);
        }
    }

    return newArr;
}

const data = [[0, 33], [66, 80], [0, 66], [33, 100]];

let arr = mergeArray(data.sort());

功能发布集（a、b）{
如果（（a[0]>=b[0]&&a[1]，你能更详细地解释一下所需转换背后的逻辑吗？为什么输入2个子数组会产生2个子数组，而输入4个子数组只产生一个数组？是否也允许负数？如果是，它们是否应该以负数方式重叠？例如：
[[0，-10]，-10，-20]=>[0, -20]
？@CertainPerformance我猜他的意思是合并重叠的值。在他的第一种情况下，他有两个数组作为输入，一个数组的最后一项是第二个数组的第一项，这意味着我们可以合并这两个范围，并创建一个从第一个数组的第一项到第二个数组的单一范围第二个数组。在第二种情况下，项目不能合并在一个范围内，因此他的输出是两个数组，在第一种情况下是重叠的。这根本不是一个aswer。这甚至不是一个注释。
[[0,33]，[66,80]，[0,66]]