将日期范围数组排序为组，其中每个组没有重叠范围（Javascript）

Question

I have an Array of objects & each object has a 'start' date & an 'end' date.

sortedDateRanges = [
    {
    id: 1,
    start: "2018-01-01",
    end: "2018-01-05",
    name: "First item"
  },
  {
    id: 2,
    start: "2018-01-02",
    end: "2018-01-08",
    name: "Second item"
  },
  {
    id: 3,
    start: "2018-01-06",
    end: "2018-01-13",
    name: "Third item"
  },
  {
    id: 4,
    start: "2018-01-14",
    end: "2018-01-14",
    name: "Fourth item"
  },
  {
    id: 5,
    start: "2018-02-01",
    end: "2018-02-15",
    name: "Fifth item"
  },
]

I need to sort these objects into groups where each group has NO overlapping date ranges. There are definitely multiple valid outputs. [[{id: 1},{id: 3},{id: 4}], [{id: 2},{id: 5}]] or [[{id: 1}, {id: 3}, {id: 5}], [{id: 2}, {id: 4}]] etc.

My current solution is just comparing each range to the previous range which doesn't produce an incorrect solution...it's just not a comprehensive solution like I am looking for. My current solution returns [[{id: 1}],[{id: 2}],[{id: 3}, {id: 4}, {id: 5}]]

export const groupUnoverlappedItems = sortedDateRanges => {
    let groups = [];
    let rangeIds = [];

    sortedDateRanges.map((current, idx, arr) => {
        if (idx === 0) {
            groups.push([current]);
            rangeIds.push(current.id);
            // return result;
        } else {
            let previous = arr[idx -1];

            // check for overlap
            let previousEnd = (new Date(previous.end)).getTime();
            let currentStart = (new Date(current.start)).getTime();
            let overlap = (previousEnd >= currentStart);

            if (overlap) {
                // if overlap, push new group
                groups.push([current]);
                rangeIds.push(current.id);
            } else if (rangeIds.indexOf(current.id) === -1) {
                groups[groups.length -1].push(current);
                rangeIds.push(current.id);
            }
        }
    });

    return groups;
};

Answer 1

I don't understand if you have a rule to define the groups, or they must be formed dinamically.

Anyway, why don't you get the object with the earliest start date, and use it to create the first object, in the first group.

You have a starting point, then you can find the object with the nearest start date, that doesn't overlap your first object end date. If you proceed sequentially, once you find a date that overlaps, you can be almost safe that is the good one to form the next group.

Once you don't find any other candidates for the first group, then you can check if another group exist (and has at least an object in it), then repeat the process, until all objects are allocated.

May I suggest to use a library, like date-fns , that helps you with useful methods to manipulate dates, and also define date intervals. Javascript has basic support for dates, using a library can save you a lot of time;)