介绍

在德国，工作时间的规定非常严格。如果您每天工作6个小时或以上，则必须至少休息30分钟。如果您工作9个小时以上，则需要休息45分钟。如果您的工作时间少于6个小时，则无需休息。

当然，您可以拆分这些休息时间，但每个部分的时间至少必须为15分钟才能计算在内。

挑战

在此挑战中，您将获得工作时间列表，并且必须使用以下规则检查是否已采取足够的休息时间：

我们w要以小时为单位的工作时间：

w < 6         -> No breaks needed
6 <= w < 9    -> 30 minute break needed
w >= 9        -> 45 minute break needed

此外，每个休息时间必须至少15分钟。另外，您总是可以休息多于所需时间。这些都是“至少”值。

输入值

您的输入将是工作时间列表。确切的格式由您决定，但是它只能包含时间值，例如小时和分钟。

例：

这里的格式是一个元组列表，而每个元组代表一个工作周期。元组中的第一个元素将是开始时间，第二个元素将是结束时间。

[("07:00","12:00"),("12:30","15:30"),("15:45","17:15")]

这导致总工作时间为9.5小时，总休息时间为45分钟。

请注意，这些工作时间不必用休息时间隔开。也可能存在彼此紧随的工作周期（示例请参见测试用例）。

另请注意，休息时间不会计入工作时间。这些是两个单独的值。

您可以假定工作期是有序的。

输出量

鉴于这种输入，输出truthy值，如果采取和足够的休息falsy如果没有价值。

规则

• 指定您在提交中使用的输入格式。
• 您不必处理空输入。总会有至少一个工作周期。
• 工作时间仅为一天，因此您不必在午夜时分上班。
• 只要您的语言附带日期/时间/任何内置函数即可。
• 允许功能或完整程序。
• 输入/输出的默认规则。
• 有标准漏洞。
• 这是代码高尔夫球，因此最低字节数获胜。决胜局是较早提交的。

测试用例

输入格式与上面的示例相同。

[（“ 07:00”，“ 12:00”），（“ 12:30”，“ 15:30”），（“ 15:45”，“ 17:15”）]-> TRUE // 9：工作30小时，休息45分钟->确定
[（“ 07:20”，“ 07:45”），（“ 07:59”，“ 11:30”），（“ 11:55”，“ 15:00”）]->假/// 7：工作时间01h，休息时间为39分钟，但由于少于15分钟，因此第一次休息不算
[（“ 06:00”，“ 09:00”），（“ 09:00”，“ 11:50”）]-> TRUE //仅工作5：50h，因此无需休息
[（“” 07:30“，” 12:00“），（” 12:30“，” 16:00“）]-> TRUE // 8小时工作，休息30分钟-> OK
[（“ 08:00”，“ 12:30”），（“ 13:05”，“ 17:45”）]-> FALSE // 9：10h工作，只有35分钟的休息时间，而不是所需的45分钟
[（“ 08:00”，“ 14:00”）]->假// 6h工作，不休息，但需要30分钟

编码愉快！

Pyth，56 52字节

La.*bgsm*ydgyd15cPt_Jmid60Q2@[0030 45)hS,/syRcJ2C\´3

[[hh,mm], [hh,mm], ...]以不带前导0s 的形式接受输入

说明：

La.*bgsm*ydgyd15cPt_Jmid60Q2@[0030 45)hS,/syRcJ2C\´3

La.*b                                                - def y(b): return absdiff(*b)

                    Jmid60Q                          - Unpack the input to mins and assign to J
                    J                                - autoassign J = V
                     m    Q                          - [V for d in Q]
                      id60                           - conv_base(V, 60)

      sm*ydgyd15cPt_J      2                         - Get the total break
                   _J                                - reverse(J)
                 Pt                                  - ^[1:-1]
                c          2                         - chop(2, ^)
                                                     -
       m                                             - [V for d in ^]
            yd                                       - y(d)
           g  15                                     - >= 15
         yd                                          - y(d)
        *                                            - y(d) * (y(d)>=15)
                                                     -
      s                                              - sum(^)

                            @[0030 45)hS,/syRcJ2C\´3 - Get the break required
                                             cJ2     - chop(J, 2)
                                           yR        - map(y, ^)
                                          s          - sum(^)
                                                     - Now have the total time worked in mins
                                         /      C\´  - ^/ord("`")
                                                     - (^/180)
                                                     - Now have the time worked in 3 hour intervals
                                      hS,          3 - sorted([^, 3])[0]
                                                     - (min(^, 3))
                                                     - Now have hours worked in 3 hour intervals capped at 9 hours
                            @[0030 45)               - [0,0,30,45][^]
                                                     - Get the break required for that time

     g                                               - break >= break required

在这里尝试

或者在这里尝试所有测试用例

Javascript，108106字节

m=>(k=t=0,m.map(l=>(a=l[0]*60+l[1],k+=t?a-b<15?0:a-b:0,b=l[2]*60+l[3],t+=b-a)),t/=60,t<6||k>44||t<9&&k>29)

接受一个数组数组。每个内部数组在每个期间分别具有开始小时和分钟以及结束小时和分钟。

f=m=>(                           // assign function to f
    k=t=0,                       // k break // t work
    m.map(l=>(                   // for each period
        a=l[0]*60+l[1],          // started time in minutes 
        k+=t?a-b<15?0:a-b:0,     // if there was a break add it
        b=l[2]*60+l[3],          // ended time in minutes
        t+=b-a                   // sum worked time (the difference)
    )),                          //
    t/=60,                       // turn t from minutes to hours
    t<6||k>44||t<9&&k>29         // the main logic
)                                //

document.body.innerHTML = '<pre>' +
  f([[07,00,12,00],[12,30,15,30],[15,45,17,15]]) + '\n' +
  f([[07,20,07,45],[07,59,11,30],[11,55,15,00]]) + '\n' +
  f([[06,00,09,00],[09,00,11,50]]) + '\n' +
  f([[07,30,12,00],[12,30,16,00]]) + '\n' +
  f([[08,00,12,30],[13,05,17,45]]) + '\n' +
  f([[08,00,14,00]]) + '\n' +
'</pre>'

Python 3、135

DSM节省了3个字节。

这是我一段时间内比较数学的解决方案之一。

def f(l):
 h=r=e=0
 for(a,b)in l:a+=a%1*2/3;b+=b%1*2/3;h+=b-a;r-=(e-a)*(e and(a-e)>.24);e=b
 return(h<6)|(6<=h<9and.5<=r)|(h>9and.74<r)

这是我的测试用例，它还显示了我期望函数如何被调用。

assert f([(07.00, 12.00), (12.30, 15.30), (15.45, 17.15)])
assert not f([(07.20, 07.45), (07.59, 11.30), (11.55, 15.00)])
assert f([(06.00, 09.00), (09.00, 11.50)])
assert f([(07.30, 12.00), (12.30, 16.00)])
assert not f([(08.00, 12.30), (13.05, 17.45)])
assert not f([(08.00, 14.00)])