获取两个数字之间未占用范围的数组

如何解决获取两个数字之间未占用范围的数组

考虑我有以下数组：

[{Id:'1',Title: 'Group A',Start: '100',End:'200'},{Id:'2',Title: 'Group B',Start: '350',End:'500'},{Id:'3',Title: 'Group C',Start: '600',End:'800'} ]

我想获得 100 到 999 之间的未占用范围。我要求的最终结果是：

[{Start: '201',End:'349'},{Start: '501',End:'599'},{Start: '801',End:'999'} ]

解决方法

您需要遍历每个数组项并找到上一个未占用的范围并将其插入到一个新数组中。然后在最后一项中，您必须检查最后一项是否占据了最后的所有空间直至最大值。如果不是，我们还需要添加该范围。您可以使用 Array.reduce 函数执行以下操作，

let sortedArr = [{Id:'1',Title: 'Group A',Start: '100',End:'200'},{Id:'2',Title: 'Group B',Start: '350',End:'500'},{Id:'3',Title: 'Group C',Start: '600',End:'800'} ];

const MIN = 100;
const MAX = 999;

let res = sortedArr.reduce((prev,curr,index,arr) => {
  obj = {Start: 0,End: 0};
  
  // checking if the first item has any unoccupied range before it's Start value.
  if(index === 0 && Number(curr.Start) > MIN) {
    obj = {Start: MIN,End: Number(curr.Start) - 1};
    prev.push(obj);
  } else if(index !== 0 && Number(arr[index - 1].End) + 1 < Number(curr.Start)) { 
  // If there is a range between the previous item's End and curr item's Start.
    obj = {Start: Number(arr[index - 1].End) + 1,End: Number(curr.Start) -1};
    prev.push(obj);
  }
  
  // checking if the last item has any range after it's End value.
  if(index === arr.length -1 && Number(curr.End) < MAX) {
    obj = {Start: Number(curr.End) + 1,End: MAX};
    prev.push(obj);
  } else {
    return prev;
  }
  
  return prev;
},[])

console.log(res);

采用回归基本的方法：从未占用的完整范围开始，循环遍历数据中的每个范围，如果它在输出中的现有未占用范围内开始（相反，第一个总是会），切掉那个unoccupied range 在数据范围的开头，并在数据范围的末尾添加一个新的 unoccupied entry 到正在被剪切的现有范围的末尾（实际上代码中更清晰）：

var range = [{ min: 100,max: 999 }];

var data = [
 {Id:'1',Start: 100,End:200 },Start: 350,End:500 },Start: 600,End:800 }
];


for (let i=0; i<data.length; ++i) {

    for (let r=0;r<range.length; ++r) {

        // check if this data matches the existing data
        // update existing data rather than create a new entry
        if (range[r].min == data[i].Start) {
            range[r].min = data[i].End+1;
            break;
        }
        
        // check if this data sits inside the range
        if (range[r].max > data[i].Start) {
            // split the range,end one where data starts and add another where data ends
            // (add the end part first before changing existing range[r].max)
            range.push({ min: data[i].End+1,max: range[r].max})
            range[r].max = data[i].Start-1;
            break;
        }
    }
}

console.log(range);

如果您的数据从超出范围的起点开始，那么您需要删除 where max<min 或明确检查此条件。

这使用了输出数据没有任何重叠数据的先决条件（排序顺序无关紧要，但输出顺序也不会排序）。

您可以在输出中将 min/max 更改为 Start/End，为清楚起见，将它们保留为不同的名称。

我也将 data.Start/data.End 转换为数字，但如果愿意，您可以将其添加到脚本中（.Start*1 无处不在或其他首选的字符串到整数转换）。>

这里有一个示例，说明如何在 javascript 中执行此操作。您可以使用 for 循环遍历对象，并可以通过从当前行选择 End+1 和从下一行选择 Start-1 为输入对象中的每一行创建一行。最后一行的 End 将为 999。

output 是您想要的结果。

var p = [
         {Id:'1',End:'800'} 
        ];

var i;
var output = [];

for (i = 0; i < p.length; i++) {
  if (i + 1 < p.length)
    output.push({ Start: Number(p[i].End) + 1,End: Number(p[i + 1].Start) - 1 });
  else
    output.push({ Start: Number(p[i].End) + 1,End: 999 });
}

console.log(output);

您将获得以下输出的 console.log(output);：

Array [Object { Start: 201,End: 349 },Object { Start: 501,End: 599 },Object { Start: 801,End: 999 }]

这是另一种稍微宽容和通用的方法，它将允许任何未排序的排除数组（排除范围甚至可能重叠）：

const excl=[[400,450],[100,200],[350,500],[600,800],[150,250]],sortedArr = [{Id:'1',End:'800'} ];

function allowedRanges(inc,excl){
var incl=[inc];
excl.forEach(x=>{
incl.forEach((r,i,a)=>{
  if (x[0]<=r[1] && x[1]>=r[0])
    a.splice(i,1,[r[0],x[0]-1],[x[1]+1,r[1]])   
});
});
// now,remove the nonsensical ones
// and return the result:
return incl.filter(r=>r[1]>r[0]);
}
// test with an unsorted array excl:
console.log(allowedRanges([1,999],excl));
// test with sortedArr:
console.log(allowedRanges([101,sortedArr.map(e=>[+e.Start,+e.End])));

获取两个数字之间未占用范围的数组

如何解决获取两个数字之间未占用范围的数组

解决方法

相关推荐