Wprowadzenie

Tutaj w Niemczech orzeczenie dotyczące czasu pracy jest bardzo surowe. Jeśli pracujesz 6 lub więcej godzin dziennie, musisz zrobić co najmniej 30-minutową przerwę. Jeśli pracujesz 9 lub więcej godzin, musisz zrobić 45-minutową przerwę. Jeśli pracujesz krócej niż 6 godzin, nie musisz robić żadnych przerw.

Oczywiście możesz podzielić te przerwy, ale każda część musi mieć co najmniej 15 minut, aby zostać policzonym.

Wyzwanie

W tym wyzwaniu otrzymasz listę okresów pracy i musisz sprawdzić, czy zrobiono wystarczającą liczbę przerw, stosując następujące zasady:

Niech wbędzie czas pracy w godzinach:

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

Dodatkowo każda przerwa musi trwać co najmniej 15 minut. Ponadto zawsze możesz zrobić więcej przerw niż potrzeba. Są to wszystkie „przynajmniej” wartości.

Wejście

Twój wkład będzie listą okresów pracy. Dokładny format zależy od Ciebie, ale musi zawierać tylko wartości czasu jako godziny i minuty.

Przykład:

Format tutaj to lista krotek, podczas gdy każda krotka reprezentuje okres pracy. Pierwszym elementem w krotce będzie czas rozpoczęcia, drugi to czas zakończenia.

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

Daje to łączny czas pracy 9,5 godziny i całkowity czas przerwy 45 minut.

Pamiętaj, że te okresy robocze nie muszą być oddzielone przerwami. Mogą również istnieć okresy robocze, które po prostu następują po sobie (przykład patrz przypadki testowe).

Pamiętaj również, że przerwy nie liczą się do czasu pracy. To są dwie osobne wartości.

Możesz założyć, że okresy pracy są uporządkowane.

Wynik

Biorąc pod uwagę te dane wejściowe, wypisz wartość prawdy, jeśli wykonano wystarczającą liczbę przerw, i wartość fałsz, jeśli nie.

Zasady

• Określ format wejściowy, którego używasz w swoim zgłoszeniu.
• Nie musisz obsługiwać pustych danych wejściowych. Zawsze będzie co najmniej jeden okres roboczy.
• Okresy pracy będą trwać tylko jeden dzień, więc nie musisz zajmować się pracą do północy.
• Daty / Godzina / Cokolwiek - Wbudowane dozwolone, pod warunkiem, że pochodzi z twojego języka.
• Dozwolona funkcja lub pełny program.
• Domyślne reguły wejścia / wyjścia.
• Obowiązują standardowe luki .
• To jest golf golfowy , więc wygrywa najmniej bajtów. Tie-breaker to wcześniejsze zgłoszenie.

Przypadki testowe

Taki sam format wejściowy jak w powyższym przykładzie.

[(„07:00”, „12:00”), („12:30”, „15:30”), („15:45”, „17:15”)] -> PRAWDA // 9: 30h pracy, 45 minut przerwy -> OK
[(„07:20”, „07:45”), („07:59”, „11:30”), („11:55”, „15:00”)] -> FALSE // 7: 01h pracy, 39 minut przerwy, ale pierwsza przerwa się nie liczy, ponieważ <15 minut
[(„06:00”, „09:00”), („09:00”, „11:50”)] -> PRAWDA // Tylko 5:50 godzin pracy, więc przerwa nie jest wymagana
[(„07:30”, „12:00”), („12:30”, „16:00”)] -> PRAWDA // 8 godzin pracy, przerwa 30 minut -> OK
[(„08:00”, „12:30”), („13:05”, „17:45”)] -> FAŁSZ // 9: 10h pracy, tylko 35 minut przerwy zamiast potrzebnych 45
[(„08:00”, „14:00”)] -> FALSE // 6 godzin pracy, bez przerw, ale potrzeba 30 minut

Happy Coding!

Pyth, 56 52 bajtów

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

Pobiera dane wejściowe w formie [[hh,mm], [hh,mm], ...]bez wiodących 0s

Wyjaśnienie:

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

Wypróbuj tutaj

Lub wypróbuj wszystkie przypadki testowe tutaj

JavaScript, 108 106 bajtów

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)

Zajmuje tablicę tablic. Każda wewnętrzna tablica ma odpowiednio godzinę początkową i minutę oraz godzinę końcową i minutę dla każdego okresu.

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

Zaoszczędź 3 bajty dzięki DSM.

To od pewnego czasu jedno z moich matematycznych rozwiązań.

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)

Oto moje przypadki testowe, pokazuje także, jak oczekuję, że funkcja zostanie wywołana.

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)])