我需要比较重叠的时间表，从2到无限数量的时间表。
例如，具有3个计划的数组将如下所示：
var dateRanges = [
{
DaysOfWeek: ['Sun', 'Mon'],
StartTime: "01:00",
StopTime: "17:00",
AllDay: false
},
{
DaysOfWeek: ['Tues', 'Wed'],
StartTime: "12:00",
StopTime: "21:59",
AllDay: true
},
{
DaysOfWeek: ['Thur', 'Sun'],
StartTime: "12:00",
StopTime: "21:59",
AllDay: true
}
]
我正在努力弄清楚如何将所有阵列相互比较。到目前为止我有这个
checkScheduleForOverlap: function (dateRanges) {
var result = dateRanges.reduce((result, current, i, arr) => {
// console.log(previous, current);
// get the previous range
if (i === 0) { return result; }
var previous = arr[i - 1];
// Schedule1
var startTime1 = new Date('1970-01-01T' + previous.StartTime + 'Z');
var stopTime1 = new Date('1970-01-01T' + previous.StopTime + 'Z');
// Schedule2
var startTime2 = new Date('1970-01-01T' + current.StartTime + 'Z');
var stopTime2 = new Date('1970-01-01T' + current.StopTime + 'Z');
previous.DaysOfWeek.forEach(function (prevDay) {
console.log(prevDay);
current.DaysOfWeek.forEach(function (currDay) {
console.log(currDay);
if (prevDay === currDay) {
var overlap = (startTime1 <= stopTime2) && (stopTime1 >= startTime2);
// store the result
if (overlap) {
// yes, there is overlap
result.overlap = true;
// store the specific ranges that overlap
result.days.push(currDay);
}
}
});
});
return result;
// seed the reduce
}, { overlap: false, days: [] });
// return the final results
console.log(result);
return result;
}
但它只将第二个数组与第一个数组进行比较，第三个数组与第二个数组进行比较。它还需要将第三个与第一个进行比较。 （如果有4个时间表，则每个时间表需要与另一个进行比较。）
我是否在正确的轨道上，以及如何让每个DaysOfWeek计划将StartTime和StopTime与其他计划中的值进行比较？
我使用静态日创建了一个假日期对象，我只是比较时间值。
如果这不是一种有效的方法，我愿意采用完全不同的方式。
答案 0 :(得分：1)
让我们关注您的问题中有关比较多个数组之间的项目的部分。现在比较的实际逻辑并不重要。
这一切都以嵌套的for循环开始：
var arr1 = [ "A", "B", "C" ];
var arr2 = [ "1", "2", "3" ];
// Runs arr1.length * arr2.length = 9 times
for (let i = 0; i < arr1.length; i += 1) {
for (let j = 0; j < arr2.length; j += 1) {
console.log(
"run", i * arr2.length + j,
"result", arr1[i], arr2[j]
);
}
}
一旦你有一个循环遍历所有两个数组对的函数，剩下要做的就是从一个数组列表中找到所有可能的对：
const arrays = [ [ "A" ], [ "B" ], [ "C" ] ];
for (let i = 0; i < arrays.length - 1; i += 1) {
// ^^^
for (let j = i + 1; j < arrays.length; j += 1) {
// ^^^^^
console.log(
JSON.stringify(arrays[i]),
JSON.stringify(arrays[j])
);
}
}
现在我们已经掌握了基础知识，我们可以将它们链接在一起并进行重构。我不得不承认重构有点个人喜好，将for循环包装在函数中是完全没问题的。
我已将第一个原则命名为combinations，并使用reduce和map代替for循环。第二个for循环现在包含在allPairs。
// Utilities:
const combinations = ([xs, ys]) =>
xs.reduce(
(cs, x) => cs.concat(ys.map(y => [x, y])),
[]
);
const allPairs = (xs) =>
xs.reduce(
(ps, x, i) => ps.concat(xs.slice(i + 1).map(y => [x, y])),
[]
);
const flatten = xxs => xxs.reduce((xs, ys) => xs.concat(ys))
const findMatches = (matchFn, arrays) => flatten(
allPairs(arrays).map(combinations)).filter(matchFn);
// App:
// Let's just stick to an easy example
const overlap = ([x, y]) => x === y;
console.log(
findMatches(
overlap,
[ [ 1, 2 ], [ 1, 3 ], [ 1, 2, 3], [ 4, 5 ], [ 1 ] ]
)
);
此方法返回重叠元素对。您必须包含自己的overlaps功能。您可以使用find代替filter来获得一些效率，typedef struct
{
// float a[SIZE_A];
// float b[SIZE_B];
// float c[SIZE_C1][SIZE_C2];
float* a;
float* b;
float c[][SIZE_C2]; // float** c;
} OBJ;
void init( OBJ* obj, void* mem )
{
float* mem_p = (float*)mem;
obj->a = mem_p;
mem_p += SIZE_A;
obj->b = mem_p;
mem_p += SIZE_B;
obj->c = ?
}
会返回第一个重叠对。如果你真的想尽早返回，甚至在构建所有对组合之前，你将不得不移动一些东西（但我无法想象性能将是一个问题）。
答案 1 :(得分：1)
我能够使用以下代码使其工作。它可能会提高效率，但对于小型列表，它可以很好地工作。
/**
* Compares to comparable objects to find out whether they overlap.
* It is assumed that the interval is in the format [from,to) (read: from is inclusive, to is exclusive).
* A null value is interpreted as infinity
*/
checkScheduleForOverlap: function (dateRanges) {
function dateRangeOverlaps (a_start, a_end, b_start, b_end) {
if (a_start <= b_start && b_start <= a_end) return true; // b starts in a
if (a_start <= b_end && b_end <= a_end) return true; // b ends in a
if (b_start < a_start && a_end < b_end) return true; // a in b
return false;
}
function multipleDateRangeOverlaps () {
var i, j;
if (arguments.length % 2 !== 0)
throw new TypeError('Arguments length must be a multiple of 2');
for (i = 0; i < arguments.length - 2; i += 2) {
for (j = i + 2; j < arguments.length; j += 2) {
if (
dateRangeOverlaps(
arguments[i], arguments[i + 1],
arguments[j], arguments[j + 1]
)
) return true;
}
}
return false;
}
var result = {
overlappingDays: [],
overlap: false
};
// for every Schedule
for (let i = 0; i < dateRanges.length; i++) {
var current = dateRanges[i];
// current Schedule
var startTime1 = current.StartTime;
var stopTime1 = current.StopTime;
current.DaysOfWeek.forEach(function (currDay) {
// console.log('currentScheduleDay', currDay);
// for every OTHER schedule
for (let j = 0; j < dateRanges.length; j++) {
var nextSchedule = dateRanges[j];
if (j === i) {
continue;
}
nextSchedule.DaysOfWeek.forEach(function (nextDay) {
// console.log('nextScheduleDay', nextDay);
if (nextDay === currDay) {
// next Schedule
var startTime2 = nextSchedule.StartTime;
var stopTime2 = nextSchedule.StopTime;
// var overlap = (startTime1 <= stopTime2) && (stopTime1 >= startTime2);
var overlap = multipleDateRangeOverlaps(startTime1, stopTime1, startTime2, stopTime2);
// store the result
if (overlap) {
// yes, there is overlap
result.overlap = true;
// store the specific ranges that overlap
result.overlappingDays.push(currDay);
}
}
});
}
});
}
// remove duplicates in result
var obj = {};
for (var i = 0, len = result.overlappingDays.length; i < len; i++) {
obj[result.overlappingDays[i]] = result.overlappingDays[i];
}
result.overlappingDays = new Array();
for (var key in obj) {
result.overlappingDays.push(obj[key]);
}
if (result.overlappingDays) {
this.scheduleDaysOverlap = result.overlappingDays;
}
}