计算跳过假期和周末的工作日

最近发现不少小伙伴都对Golang很感兴趣，所以今天继续给大家介绍Golang相关的知识，本文《计算跳过假期和周末的工作日》主要内容涉及到等等知识点，希望能帮到你！当然如果阅读本文时存在不同想法，可以在评论中表达，但是请勿使用过激的措辞~

我有这个问题，流程从一个初始日期开始，比如说 2022-04-14，我必须在这个日期上添加十天，但我必须考虑周末和假期，所以也许在初始日期之间最终日期我们有一个周末和一个假期，最终日期将是 2022 年 4 月 27 日。还必须考虑初始日期是否从周末或节假日开始。

这就是问题所在。

我的第一个方法是创建一个循环，在最初的一天加上十天之间以及每个周六、周日和节假日总和一天之间检查每天，所以我将有十天加三天，这个结果将添加到我的初始日期最终计算出最终日期。

我的问题是，是否有其他解决方案或实现可以更有效？因为这也许将来会被很多人使用。

正确答案

另外，不要忘记在添加累积的额外天数（周末和节假日）时，这些天数可能会涵盖新的周末和节假日，因此您必须“递归”执行此操作。

最简单的解决方案

最简单的解决方案可以从初始日期开始，增加一天，然后检查每个日期是否是可跳过的（周末或假期）日。如果没有，请减少天数，然后重复，直到添加所需的天数。

它可能是这样的：

func adddays(start time.time, days int) (end time.time) {
    for end = start; days > 0; {
        end = end.adddate(0, 0, 1)
        if !skippable(end) {
            days--
        }
    }
    return end
}

func skippable(day time.time) bool {
    if wd := day.weekday(); wd == time.saturday || wd == time.sunday {
        return true
    }
    if isholiday(day) {
        return true
    }
    return false
}

func isholiday(day time.time) bool {
    return false // todo
}

测试它：

d := time.date(2022, time.april, 14, 0, 0, 0, 0, time.utc)
fmt.println(adddays(d, 0))
fmt.println(adddays(d, 1))
fmt.println(adddays(d, 10))

哪个输出（在 Go Playground 上尝试一下）：

2022-04-14 00:00:00 +0000 utc
2022-04-15 00:00:00 +0000 utc
2022-04-28 00:00:00 +0000 utc

更快的解决方案

更快的解决方案可以避免日复一日的循环。

计算周末天数：知道初始日期是哪一天，并知道您想要步进多少天，我们就可以计算其间的周末天数。例如。如果我们必须步进 14 天，那就是整整 2 周，其中肯定包括 4 个周末。如果我们必须多走一步，例如16 天，其中还包括 2 个整周（4 个周末），以及可选的 1 或 2 天，我们可以轻松检查。

计算假期：我们可以使用一个技巧来在排序切片中列出假期（按日期排序），这样我们就可以轻松/快速地找到两个日期之间的天数。我们可以在排序切片中二分查找某个时间段的开始日期和结束日期，而一个时间段中的假期数就是这两个索引之间的元素数量。注意：周末假期不得包含在此切片中（否则将被计算两次）。

让我们看看这个实现是怎样的：

// holidays is a sorted list of holidays
var holidays = []time.time{
    time.date(2022, time.april, 15, 0, 0, 0, 0, time.utc),
}

func adddaysfast(start time.time, days int) (end time.time) {
    weekenddays := days / 7 * 2 // full weeks
    // account for weekends if there's fraction week:
    for day, fraction := start.adddate(0, 0, 1), days%7; fraction > 0; day, fraction = day.adddate(0, 0, 1), fraction-1 {
        if wd := day.weekday(); wd == time.saturday || wd == time.sunday {
            weekenddays++
        }
    }

    end = start.adddate(0, 0, days+weekenddays)

    first := sort.search(len(holidays), func(i int) bool {
        return !holidays[i].before(start)
    })
    last := sort.search(len(holidays), func(i int) bool {
        return !holidays[i].before(end)
    })

    // there are last - first holidays  in the range [start..end]
    numholidays := last - first
    if last < len(holidays) && holidays[last].equal(end) {
        numholidays++ // end is exactly a holiday
    }

    if numholidays == 0 {
        return end // we're done
    }

    // we have to add numholidays, using the same "rules" above:
    return adddaysfast(end, numholidays)
}

测试它：

d := time.date(2022, time.april, 14, 0, 0, 0, 0, time.utc)
fmt.println(adddaysfast(d, 0))
fmt.println(adddaysfast(d, 1))
fmt.println(adddaysfast(d, 10))

输出（在Go Playground上试试）：

2022-04-14 00:00:00 +0000 utc
2022-04-18 00:00:00 +0000 utc
2022-04-29 00:00:00 +0000 utc

改进 adddaysfast()

还有改进adddaysfast()的方法：

• 检查小数周中周末的初始循环可以用算术计算代替（参见 example）
• 可以用迭代解决方案代替递归
• 另一种解决方案可以将周末列为假期，因此可以删除计算周末的第一部分（不得包含重复项）

我会像这样计算工作日。不包括假期查找，它没有循环，时间和空间复杂度为 o(1)：

• 计算范围的开始日期和结束日期之间的整数天数

• 将其除以 7。商是该范围内的整数周数；余数是剩余的一周的小数部分，以整天计算。

• 该范围内的基本工作日数是该范围内的周数乘以 5，因为每 7 天的时间段（无论何时开始）都包含 2 个周末。

• 必须调整最后的小数周（以整天为单位）以删除任何周末。这是小数周中的整数天数和范围结束日期的星期几的函数。

• 假期查找留给读者作为练习，因为这太依赖于文化、地区和业务，无法解决。应该注意的是，这里的逻辑中有一个内置的假设，即“假期”不会发生在周六或周日。

func BusinessDays(start time.Time, end time.Time) int {
    from := toDate(start)
    thru := toDate(end)
    weeks, days := delta(from, thru)

    adjustedDays := adjustDays(days, thru.Weekday())

    businessDays := ( ( weeks * 5) + adjustedDays ) - holidaysInRange(from, thru)

    return businessDays

}

func toDate(t time.Time) time.Time {
    y, m, d := t.Date()
    adjusted := time.Date(y, m, d, 0, 0, 0, 0, t.Location())
    return adjusted
}

func holidaysInRange(from, thru time.Time) (cnt int) {
    // TODO: Actual implementation left as an exercise for the reader
    return cnt
}

func delta(from, thru time.Time) (weeks, days int) {
    const seconds_per_day = 86400
    totalDays := (thru.Unix() - from.Unix()) / seconds_per_day

    weeks = int(totalDays / 7)
    days = int(totalDays % 7)
    return weeks, days
}

func adjustDays(days int, lastDay time.Weekday) int {
    adjusted := days
    switch days {
    case 1:
        switch lastDay {
        case time.Saturday:
        case time.Sunday:
            adjusted -= 1
        }
    case 2:
        switch lastDay {
        case time.Sunday:
            adjusted -= 2
        case time.Saturday:
        case time.Monday:
            adjusted -= 1
        }
    case 3:
        switch lastDay {
        case time.Sunday:
        case time.Monday:
            adjusted -= 2
        case time.Tuesday:
        case time.Saturday:
            adjusted -= 1
        }
    case 4:
        switch lastDay {
        case time.Sunday:
        case time.Monday:
        case time.Tuesday:
            adjusted -= 2
        case time.Wednesday:
        case time.Saturday:
            adjusted -= 1
        }
    case 5:
        switch lastDay {
        case time.Sunday:
        case time.Monday:
        case time.Tuesday:
        case time.Wednesday:
            adjusted -= 2
        case time.Thursday:
        case time.Saturday:
            adjusted -= 1
        }
    case 6:
        switch lastDay {
        case time.Sunday:
        case time.Monday:
        case time.Tuesday:
        case time.Wednesday:
        case time.Thursday:
            adjusted -= 2
        case time.Friday:
        case time.Saturday:
            adjusted -= 1
        }
    }

    return adjusted
}

今天关于《计算跳过假期和周末的工作日》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！