【问题标题】:Check if a date range touches a time range检查日期范围是否触及时间范围
【发布时间】:2017-06-20 20:27:09
【问题描述】:

山姆是一名兼职卡车司机。如果他从 0200 时至 0600 时开车,他将获得特殊津贴。他的老板想知道这段时间所有旅行都触及了哪些。以下是他最近 4 次旅行的详细信息。

行程 1:

开始日期时间:2017 年 1 月 1 日 00.15.00
结束日期时间:2017 年 1 月 3 日 01.45.00

感动:真

第二次旅行:

开始日期时间:2017 年 1 月 4 日 13.00.00
结束日期时间:2017 年 1 月 5 日 13.00.00

感动:真

第三次旅行:

开始日期时间:2017 年 1 月 6 日 00.00.00
结束日期时间:2017 年 1 月 6 日 05.00.00

感动:真

第四次旅行:

开始日期时间:2017 年 1 月 6 日 06.01.00
结束日期时间:2017 年 1 月 6 日 23.00.00

感动:假

我想出了我自己的实现来在 java 中找到这个,其中很少有 if 案例,但我有这种感觉,我正在重新发明轮子。找出日期范围是否触及时间范围的最佳方法是什么?

编辑:添加以下方法

    public boolean isTripTouchingTimeRange(Date startDate, Date endDate, AllowanceDefinition def) {

    int checkConstant = HOURS_IN_A_DAY - (def.getEndMinute() - def.getStartMinute());
    // HOURS_IN_A_DAY = 1440 MINUTES (2400 HRS) ; def.getEndMinute() = 360
    // MINUTES (0600 HRS) ; def.getStartMinute() = 120 MINUTES (0200 HRS)

    DateTime start = new DateTime(startDate);
    DateTime end = new DateTime(endDate);
    if (DateUtil.subtractDates(start.toDate(), end.toDate()) > checkConstant) {
        return true;
    } else if (end.withTimeAtStartOfDay().isAfter(start.withTimeAtStartOfDay())
            && (end.getMinuteOfDay() > def.getStartMinute())) {
        return true;
    } else if (start.getMinuteOfDay() <= def.getEndMinute() && def.getStartMinute() <= end.getMinuteOfDay()) {
        return true;
    }
    return false;
    }

【问题讨论】:

  • Half-Open 方法经常被明智地用于定义时间跨度的日期时间工作。在 Half-Open 中,开头是inclusive,而结尾是exclusive。这意味着您的特殊时间跨度从凌晨 2 点开始,一直持续到(但不包括)早上 6 点。因此,如果 06.01.0006.00.00,您的最后一个示例也将返回 false

标签: java math time language-agnostic overlap


【解决方案1】:

这个问题类似于圆形值的交集。

如果您的解决方案使用了很多案例,请考虑三角类比 here。使用余弦函数解决了逐日回绕和非平凡区间重叠的问题。

日期和时间可以转换成角度,比如

TimeAngle = Pi * TimeHrs / 12

请注意,时间范围和行程时间都应该“标准化”:

  • 如果行程超过一天,则应替换为 0..2*Pi 角度间隔。
    在其他情况下:
    • 将行程开始日的 00:00 定义为 0
    • 获取起始角度TripStartAngle = Pi * StartTripTimeHrs / 12.
      例如,对于 06:00,时间角度为 Pi*6/12 = Pi/2 = 90 degree(想象 24 小时钟面上的时针角度)
    • 获取结束角度TripEndAngle = Pi * EndTripTimeHrs / 12。如果结束角度小于开始角度(由于日期变化),则添加 2*Pi。
      例如,对于 15:00,时间角度为 Pi*15/12 = 1.25 * Pi
      但是对于 03:00 时间角度是
      Pi*3/12 = Pi/4 - less than starting Pi/2, so add 2*Pi, and result is 2.25*Pi

【讨论】:

  • 我不确定我是否完全理解您的回答。我不认为这是一个完整或最好的解决方案,尤其是当我尝试将它与我的问题中的 Trip 1 联系起来时。我们将如何解释多次触摸?您能否提供有关 TimeAngle 概念的详细信息/建议可读性,以便我在评论您的答案时不会感到赤裸裸。 :)
  • 据我了解,您需要确定时间间隔相交的事实,而不是其数量。在这种情况下,算法是合适的。使用这种算法,首先必须“标准化”间隔 - 如果时间跨度超过一天,则可以用全圆角 0..2*Pi 替换它。我将给出一些时间到角度转换的例子。
  • 添加了我遵循的方法。据我了解,您的方法将我对时间的线性考虑变成了一种循环方式。对吗?我认为两者的工作方式相同。
  • 似乎这个条件(end.getMinuteOfDay() &gt; def.getStartMinute()) 不足以返回true。区间相交需要两个 if
【解决方案2】:

我应该先用代码写出来,因为我认为这可能更直接(或者至少对我来说很熟悉)以毫秒时间戳来考虑。如果我有时间,我仍然可以回去这样做。

在相关说明中,我发现Interval trees 是一本有趣的读物,尽管我没有继续阅读。

我不相信以下是正确的,尤其是我关于如何选择 0200/0600 的日期部分的“规则”。需要磨擦测试,但是。 . .

如果 Sam 开车 20 小时或更长时间进行一次旅行,那么他已经以某种方式触及了时间范围。 (例如,行程 1 和 2)

如果 Sam 每次旅行的时间少于 20 小时,那么我们可以使用他的旅行持续时间来限制我们的可能性范围。

0200/0600 的日期分量是根据开始日期建立的。如果 startDateTime 的时间部分介于 0000 和 0600(含)之间,则 0200/0600 共享 startDateTime 的日期部分,否则为次日。

duration = endDateTime - startDateTime mustStartTime = 0200 - duration mustEndTime = 0600 + duration touched = (startDateTime >= mustStartTime && endDateTime <= mustEndTime)

第三次旅行

  • 开始日期时间:2017 年 1 月 6 日 00.00.00
  • 结束日期时间:2017 年 1 月 6 日 05.00.00
  • 触动:真

duration = 5 hours mustStartTime = 2100 = 0200 - 5 mustEndTime = 1100 = 0600 + 5 touched = (0000 >= 2100 && 0500 <= 1100) = (true && true)

第四次旅行

  • 开始日期时间:06-JAN-2017 06.01.00
  • 结束日期时间:2017 年 1 月 6 日 23.00.00
  • 触动:错误

duration = 16hr 59min mustStartTime = 1001 = 0200 - 16 hr 59 min mustEndTime = 2159 = 0500 + 16 hr 59 min touched = false = (0601 >= 1001 && 2300 <= 2159) = (false && false)

行程 5

  • 开始日期时间:2017 年 1 月 6 日 03.00.00
  • EndDateTime : 06-JAN-2017 04.00.00
  • 触动:真

duration = 1 hour mustStartTime = 0100 = 0200 - 1 hour mustEndTime = 0700 = 0600 + 1 hour touched = true = (0300 >= 0100 && 0400 <= 0700) = (true && true)

行程 6

  • 开始日期时间:2017 年 1 月 6 日 00.00.00
  • EndDateTime : 06-JAN-2017 01.30.00
  • 触动:错误

duration = 1hr 30 min mustStartTime = 0030 = 0200 - 1hr 30 min mustEndTime = 0730 = 0600 + 1hr 30 min touched = false = (0000 >= 0030 && 0130 <= 0730) = (false && true)

行程 7

  • 开始日期时间:2017 年 1 月 6 日 05.00.00
  • EndDateTime : 06-JAN-2017 06.00.00
  • 触动:真

duration = 1 hour mustStartTime = 0100 = 0200 - 1 hour mustEndTime = 0700 = 0600 + 1 hour touched = (0500 >= 0100 && 0600 <= 0700) = (true && true)

更新

现在有代码和测试。所有的断言都是正确的!绝对感觉像是在重新发明轮子!

public class OverlappingDateRangeUtil {

    /**
     * 1000 ms * 60 s * 60 m
     */
    public static final long MS_IN_AN_HOUR = 1000 * 60 * 60;

    public static final long MS_IN_TWO_HOURS = 2 * MS_IN_AN_HOUR;

    public static final long MS_IN_SIX_HOURS = 3 * MS_IN_TWO_HOURS;

    public static final long MS_IN_TWENTY_HOURS = 20 * MS_IN_AN_HOUR;

    private static boolean tripLongerThanTwentyHours(long duration) {
        return duration >= MS_IN_TWENTY_HOURS;
    }

    private static long getTruncDateFor0200And0600(Date start) {
        Calendar cal = new GregorianCalendar();
        cal.setTime(start);

        int startHour = cal.get(Calendar.HOUR);

        cal.set(Calendar.HOUR, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);

        boolean after0600 = startHour >=6 && start.getTime() % 60000 > 0;
        if(after0600) {
            cal.add(Calendar.DATE, 1);
        }
        return cal.getTimeInMillis();
    }

    public static boolean dateRangeTouches0200to0600(Date start, Date end) {
        boolean toReturn = false;
        long duration = end.getTime() - start.getTime();
        if(tripLongerThanTwentyHours(duration)) {
            toReturn = true;
        }
        else {
            long truncTestDate = getTruncDateFor0200And0600(start);
            long oh200 = truncTestDate + MS_IN_TWO_HOURS;
            long oh600 = truncTestDate + MS_IN_SIX_HOURS;
            long mustStart = oh200 - duration;
            long mustEnd = oh600 + duration;
            toReturn = start.getTime() >= mustStart && end.getTime() <= mustEnd;
        }
        return toReturn;
    }
}

public class OverlappingDateRangeUtilTest {

    private DateFormat dateTimeFormat;

    @Before
    public void setUp() throws Exception {
        dateTimeFormat = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");
    }

    @Test
    public void testDateRangeTouches0200to0600() throws ParseException {
        Date trip1Start = dateTimeFormat.parse("01/01/2017 00:15:00");
        Date trip1End = dateTimeFormat.parse("01/03/2017 01:45:00");
        assertTrue(OverlappingDateRangeUtil.dateRangeTouches0200to0600(trip1Start, trip1End));

        Date trip2Start = dateTimeFormat.parse("01/04/2017 13:00:00");
        Date trip2End = dateTimeFormat.parse("01/05/2017 13:00:00");
        assertTrue(OverlappingDateRangeUtil.dateRangeTouches0200to0600(trip2Start, trip2End));

        Date trip3Start = dateTimeFormat.parse("01/06/2017 00:00:00");
        Date trip3End = dateTimeFormat.parse("01/06/2017 05:00:00");
        assertTrue(OverlappingDateRangeUtil.dateRangeTouches0200to0600(trip3Start, trip3End));

        Date trip4Start = dateTimeFormat.parse("01/06/2017 06:01:00");
        Date trip4End = dateTimeFormat.parse("01/06/2017 23:00:00");
        assertFalse(OverlappingDateRangeUtil.dateRangeTouches0200to0600(trip4Start, trip4End));

        Date trip5Start = dateTimeFormat.parse("01/06/2017 06:01:00");      
        Date trip5End = dateTimeFormat.parse("01/06/2017 06:01:00");
        assertFalse(OverlappingDateRangeUtil.dateRangeTouches0200to0600(trip5Start, trip5End));

        Date trip6Start = dateTimeFormat.parse("01/06/2017 04:00:00");      
        Date trip6End = dateTimeFormat.parse("01/06/2017 04:00:00");
        assertTrue(OverlappingDateRangeUtil.dateRangeTouches0200to0600(trip6Start, trip6End));

        Date trip7Start = dateTimeFormat.parse("01/06/2017 03:00:00");      
        Date trip7End = dateTimeFormat.parse("01/06/2017 04:00:00");
        assertTrue(OverlappingDateRangeUtil.dateRangeTouches0200to0600(trip7Start, trip7End));

        Date trip8Start = dateTimeFormat.parse("01/06/2017 00:00:00");      
        Date trip8End = dateTimeFormat.parse("01/06/2017 01:30:00");
        assertFalse(OverlappingDateRangeUtil.dateRangeTouches0200to0600(trip8Start, trip8End));
    }

}

【讨论】:

  • 这与我尝试的类似。我唯一能补充的是那些想知道 20 来自哪里的人(它的 24 -(6-2))。这样,我们也可以保持将 6 和 2 作为配置的灵活性。 @Jon Sampson 正如你所说,感觉有点过头了。
【解决方案3】:

问题不完整。

异常

在日期时间工作中,我们会遇到异常。 Daylight Saving Time (DST) 是最常见的。但是我们也有政治家经常重新定义时区的问题,就像过去几年在Turkey (2016)、Russia (2016, 2014, 2011), Venezuela (2016, 2007) 和其他地点。

因此,您必须决定如何处理此类异常。例如,在 DST 切换时,一天可以是 23 或 25 小时。在美国,DST 表示没有凌晨 2 点或出现两次的凌晨 2 点。请注意,在美国以外的其他地方一天中的其他时间会发生 DST 转换。

时区

除非您选择忽略此类异常,否则您不能简单地处理日期和时间。您需要时区的上下文来确定日期+时间的含义。

仅在日期时间工作中的日期和时间通常被称为“本地日期时间”,意思是任何地点而不是特定地点。因此,这代表一个时刻,时间轴上的一个点。本地日期时间是关于一系列可能的时刻的模糊概念,时间跨度超过 26 小时,时区比 UTC 早 14 小时,比 UTC 晚 12 小时。应用时区来确定实际时刻,即时间线上的特定点。

【讨论】:

  • 都是需要注意的地方。但是,如果我们将查找日期范围是否触及时间范围视为数学问题,我认为,这里没有什么可以回答这个问题。
  • 我的回答的重点是,将主题视为简单的通用数学问题是天真的。日期时间工作很复杂。
猜你喜欢
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2017-01-28
  • 1970-01-01
相关资源
最近更新 更多