소개

여기서 독일의 노동 시간 판결은 매우 엄격합니다. 하루 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 분입니다.

이러한 근무 기간을 휴식 시간으로 구분할 필요는 없습니다. 서로를 따르는 작업 기간도있을 수 있습니다 (예 : 테스트 사례 참조).

또한 휴식 시간은 근무 시간에 포함되지 않습니다. 그것들은 두 개의 분리 된 값입니다.

근무 기간이 주문되었다고 가정 할 수 있습니다.

산출

이 입력, 출력 A가 주어 truthy의 충분한 휴식 촬영하고 있다면 값을 falsy 값이 아닌 경우.

규칙

• 제출에 사용중인 입력 형식을 지정하십시오.
• 빈 입력을 처리 할 필요가 없습니다. 항상 최소한 하나의 작업 기간이 있습니다.
• 근무 기간은 하루 동안 만 지속되므로 자정에 걸쳐 업무를 처리 할 필요가 없습니다.
• 언어와 함께 제공되는 한 날짜 / 시간-/ 무엇이든 내장이 허용됩니다.
• 기능 또는 전체 프로그램이 허용됩니다.
• 입 / 출력의 기본 규칙 .
• 표준 허점이 적용됩니다.
• 이것은 code-golf 이므로 바이트 수가 가장 적습니다. 타이 브레이커는 이전에 제출되었습니다.

테스트 사례

위의 예와 동일한 입력 형식입니다.

[( "07:00", "12:00"), ( "12:30", "15:30"), ( "15:45", "17:15")]-> 참 // 9 : 30 시간 작업, 45 분 휴식-> 확인
[( "07:20", "07:45"), ( "07:59", "11:30"), ( "11:55", "15:00")]-> FALSE // 7 : 01 시간 작업, 39 분 휴식, <15 분 때문에 첫 휴식 시간 계산
[( "06:00", "09:00"), ( "09:00", "11:50")]-> TRUE // 5:50 시간 만 일하므로 휴식이 필요 없습니다.
[( "07:30", "12:00"), ( "12:30", "16:00")]-> TRUE // 8 시간 작업, 30 분 휴식-> 확인
[( "08:00", "12:30"), ( "13:05", "17:45")]-> FALSE // 9:10 시간 작업, 필요한 시간 대신 35 분 휴식
[( "08:00", "14:00")]-> FALSE // 6 시간 작업, 휴식 없음, 그러나 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

여기 사용해보십시오

또는 여기에서 모든 테스트 사례를 시도하십시오.

자바 스크립트, 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>'

파이썬 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)])