0

在过去的一个半星期里，我一直在研究这个算法，但我无法让它工作。

基本上我有一个时间表（我知道“边界”的时间值），我有红色部分（人们进出工作场所的活动）。我想知道人们在他们的日程安排中在工作场所度过的时间，我不在乎他们是在工作之前还是之后，或者在午休时间。

你有什么建议吗？关于我可以在这里应用的数学理论或规则？或您看到的类似问题可以指出我吗？我一直很难找到解决方案。任何帮助，将不胜感激。

图片

例如：

时间表：
7:30am（开始） 12:00pm（午休）
1:30pm（endLunchBreak） 5:00pm（endOfWorkday）

一天中的人员流动：
IN：早上 6:50，OUT：早上 6:55
IN：早上 7:00，OUT：上午 11:45
IN：下午 1:45，OUT：下午 5:05

所以，我的预期输出将是一个时间跨度：7:30（它忽略了工作时间之外的工作时间）

4

4 回答 4

3

我会将其视为状态机问题。有四种状态：S+W+、S-W+、S+W-、SW-。计划时间对应于 S+ 状态，工人在场对应于 W+ 状态。目标是将 S+W+ 中的时间添加到相交时间。

有效的转换是：

S+W+ End of schedule -> S-W+
S+W+ Worker leaves -> S+W-
S-W+ Start of schedule -> S+W+
S-W+ Worker leaves -> S-W-
S+W- End of schedule -> S-W-
S+W- Worker arrives -> S+W+
S-W- Start of schedule -> S+W-
S-W+ Worker arrives -> S-W+

按时间顺序处理事件，从状态 SW- 开始。如果两个事件同时发生，则按任一顺序处理。

在过渡到 S+W+ 时，请注意时间。在从 S+W+ 过渡时，从过渡时间中减去最后记录的时间，并将结果添加到相交时间。

于 2013-07-28T18:17:23.427 回答
2

将一天分成 1440 个一分钟增量。这是你设定的空间。

  • 设置“S”，即预定分钟，是该空间的一个子集。
  • 设置“W”，花在工作上的时间量，是该空间的一个子集。

“S”和“W”的交集是该人在他们的日程安排内的时间量（以分钟为单位 - 根据您的需要转换为 hh:mm）。

使用其他集合算法，您可以找到它们应该存在但不存在的时间，等等。

于 2013-07-28T16:21:40.643 回答
0

您可能想考虑使用这个库，但要小心，它完全忽略了DateTime.Kind，不知道时区，也不尊重夏令时。

  • 在Utc种类上使用是安全的。
  • Local永远不要在种类上使用它。
  • 如果您在Unspecified种类上使用它，请确保您了解上下文是什么。如果它可能是某个具有 DST 的时区的当地时间，那么您的结果可能正确，也可能不正确。

除此之外，您应该能够使用它的交集功能。

于 2013-07-28T18:31:47.257 回答
0

听起来 LINQ 在这里应该可以很好地工作。我制作了一个简短的示例，使用我的Noda Time库，因为它比 .NET 对“一天中的时间”有更好的支持，但如有必要，您可以对其进行调整。

这个想法基本上是你有两个周期集合，你只对交集感兴趣 - 你可以找到任何计划周期与任何移动周期的交集 - 很容易通过使用一个不相交的周期来打折0 长度周期。

这是完整的代码，它确实给出了 7 小时 30 分钟的总时间：

using System;
using System.Collections.Generic;
using System.Linq;
using NodaTime;

class Test
{
    static void Main()
    {
        var schedule = new List<TimePeriod>
        {
            new TimePeriod(new LocalTime(7, 30), new LocalTime(12, 0)),
            new TimePeriod(new LocalTime(13, 30), new LocalTime(17, 0)),
        };

        var movements = new List<TimePeriod>
        {
            new TimePeriod(new LocalTime(6, 50), new LocalTime(6, 55)),
            new TimePeriod(new LocalTime(7, 0), new LocalTime(11, 45)),
            new TimePeriod(new LocalTime(13, 45), new LocalTime(17, 05))
        };

        var durations = from s in schedule
                        from m in movements
                        select s.Intersect(m).Duration;
        var total = durations.Aggregate((current, next) => current + next);
        Console.WriteLine(total);
    }
}

class TimePeriod
{
    private readonly LocalTime start;
    private readonly LocalTime end;

    public TimePeriod(LocalTime start, LocalTime end)
    {
        if (start > end)
        {
            throw new ArgumentOutOfRangeException("end");
        }
        this.start = start;
        this.end = end;
    }

    public LocalTime Start { get { return start; } }
    public LocalTime End { get { return end; } }
    public Duration Duration { get { return Period.Between(start, end)
                                                  .ToDuration(); } }

    public TimePeriod Intersect(TimePeriod other)
    {
        // Take the max of the start-times and the min of the end-times
        LocalTime newStart = start > other.start ? start : other.start;
        LocalTime newEnd = end < other.end ? end : other.end;
        // When the two don't actually intersect, just return an empty period.
        // Otherwise, return the appropriate one.
        if (newEnd < newStart)
        {
            newEnd = newStart;
        }
        return new TimePeriod(newStart, newEnd);
    }
}
于 2013-07-28T19:29:08.483 回答