找到一个可以容纳新时间戳的时隙并计算频率

Question

我有一系列时隙：

[
"00:00-00:15",
"00:15-00:30",
.
.
.
"11:15-11:30",
"11:30-11:45",
"11:45-00:00"
]

我有一个传入时间戳的列表，以及一些数据，看起来像：

20:18 apple
20:07 bananas
00:12 apple
.
.
.
13:52 cake

我基本上想在最后对这些进行分组，并显示以下内容：

.
. 
20:15-20:30 apple 1 bananas 2, 
20:30-20:45 cake 5, 
20:45-21:00 apple 3, egg 1, 
.
.
.

我想到的方法是遍历所有时隙，找出哪个时隙可以容纳时间戳。我能做什么更好的事情来优化它吗？

此外，我也不知道如何在一个时隙下存储多个对象的频率。我应该使用JSON吗？

这是我的尝试。有很多事情在发生。我已经大大简化了我的问题陈述，以避免任何混乱，但自从妮娜·朔尔茨问道：

var express = require("express");
var router = express.Router();
var axios = require("axios");
function convertUTC(t) {
let unix_timestamp = t;
var date = new Date(unix_timestamp * 1000);
var hours = ("0" + date.getHours()).slice(-2);
var minutes = "0" + date.getMinutes();
var formattedTime = hours + ":" + minutes.substr(-2);
return formattedTime;
}
function generateTimeSlots() {
try {
var x = 15;
var times = [];
var tt = 0;
for (var i = 0; tt < 24 * 60; i++) {
hh = Math.floor(tt / 60);
mm = tt % 60;
beg = ("0" + (hh % 12)).slice(-2) + ":" + ("0" + mm).slice(-2);
hh = Math.floor((tt + 15) / 60);
mm = (tt + 15) % 60;
end = ("0" + (hh % 12)).slice(-2) + ":" + ("0" + mm).slice(-2);
times[i] = beg + "-" + end;
tt = tt + x;
}
return times;
} catch (error) {
console.log(error);
}
}
router.post("/process-logs", async (req, res) => {
fileStrings = req.body.logFiles;
parallelCount = req.body.parallelFileProcessingCount;
times = generateTimeSlots();
for (var i = 0; i < fileStrings.length; i++) {
await axios.get(fileStrings[i]).then(function (response) {
lines = response.data.split(/r?n/);
for (var j = 0; j < lines.length; j++) {
time = convertUTC(lines[j].split(" ")[1]);
console.log(time);
}
});
}
res.send(times);
res.send("done");
});
module.exports = router;

Answer 1

一种适用于任意范围的非常简单而天真的方法(具有O(n^2(时间复杂性(是创建一个辅助映射，遍历每个槽并找到匹配的时间戳。如果匹配，则更新地图中相应水果的计数。类似这样的东西：

const slots = [ '00:00-00:15', '11:30-11:45', '13:25-14:00', '20:00-20:30'];
const data = ['20:18 apple','00:11 apple', '20:07 bananas', '20:27 bananas', '00:12 apple', '13:52 cake', '11:22 cake'];
function groupTimeslots(slots, fruitData) {
const timeSlotMap = {};
for (const key of slots) {
timeSlotMap[key] = {};
}
for (const slot of slots) {
for (const entry of fruitData) {
const [timestamp, fruit] = entry.split(' ');
if (isBetween(slot, timestamp)) {
timeSlotMap[slot][fruit] = timeSlotMap[slot][fruit] ? ++timeSlotMap[slot][fruit] : 1;
}
}
}
return timeSlotMap;
}
function isBetween(slot, timestamp) {
const [start, end] = slot.split('-');
const timestampMins = toMinutes(timestamp);
return timestampMins > toMinutes(start) && timestampMins < toMinutes(end);
}
function toMinutes(timestamp) {
const [hours, minutes] = timestamp.split(':');
return Number.parseInt(hours) * 60 + Number.parseInt(minutes);
}

console.log(groupTimeslots(slots, data));

Answer 2

您可以将索引分配给特定的时隙。然后我们可以将传入时间转换为索引。

一个指数可以通过多少"；槽"；继续计算特定的时间，sou我们可以用分钟除以15得到指数。

[
"00:00-00:15", // 0th -> index = 0
"00:15-00:30", // 1st -> index = 1
.
.
.
"11:15-11:30", // 93th
"11:30-11:45", // 94th
"11:45-00:00" // 95th -> index = 95
]

const indexToTime = (index) => {
const hour = Math.floor(15 * index / 60) % 24
const minute = (15 * index) % 60
const h = `${hour}`.padStart(2, 0)
const m = `${minute}`.padStart(2, 0)
const time = `${h}:${m}`
return time
}
const timeToIndex = (time) => {
const [hour, minute] = time.split(':')
const [h, m] = [parseInt(hour), parseInt(minute)]
const index = hour * 4 + Math.floor(minute / 15)
return index
}
const slots = [...Array(24 * 60 / 15)].map((_, i) => `${indexToTime(i)}-${indexToTime(i+1)}`)
console.log('slots =', slots)
const records = ['20:47 apple', '20:18 apple', '20:17 bananas', '20:43 cake', '20:18 bananas', '20:31 cake', '20:30 cake', '20:40 cake', '20:39 cake', '20:49 apple', '20:54 egg', '20:50 apple']
console.log('records =', records)
const stats = []
records.forEach(record => {
const [time, item] = record.split(' ')
const index = timeToIndex(time)
if (!stats[index]) {
stats[index] = {[item]: 1}
} else if(!stats[index][item]) {
stats[index][item] = 1
} else {
stats[index][item]++
}
})
console.log('stats =', stats)
const statsRecords = slots.map((time, index) => ({ time, stats: stats[index] }))
console.log('statsRecords =', statsRecords)
const display = (statsRecords) => {
return statsRecords.map(({ time, stats = {} }) => `${time} ${Object.entries(stats).map(([item, count]) => `${item} ${count}`).join(', ')}`).join('n')
}
console.log(display(statsRecords))