Einführung

Hier in Deutschland sind die Arbeitszeiten sehr streng geregelt. Wenn Sie 6 oder mehr Stunden am Tag arbeiten, müssen Sie mindestens 30 Minuten Pause einlegen. Wenn Sie 9 oder mehr Stunden arbeiten, müssen Sie eine 45-minütige Pause einlegen. Wenn Sie weniger als 6 Stunden arbeiten, müssen Sie keine Pausen einlegen.

Natürlich können Sie diese Pausen teilen, aber jeder Teil muss mindestens 15 Minuten lang sein, um gezählt zu werden.

Die Herausforderung

In dieser Herausforderung erhalten Sie eine Liste der Arbeitsperioden und müssen anhand der folgenden Regeln prüfen, ob genügend Pausen eingelegt wurden:

Geben Sie wdie Arbeitszeit in Stunden an:

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

Außerdem muss jede Pause mindestens 15 Minuten dauern. Sie können auch immer mehr Pausen einlegen als nötig. Das sind alles "mindestens" Werte.

Eingang

Ihre Eingabe wird eine Liste von Arbeitsperioden sein. Das genaue Format liegt bei Ihnen, es darf jedoch nur Zeitangaben wie Stunden und Minuten enthalten.

Beispiel:

Das Format hier ist eine Liste von Tupeln, während jedes Tupel eine Arbeitsperiode darstellt. Das erste Element in einem Tupel ist die Startzeit, das zweite Element die Endzeit.

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

Dies ergibt eine Gesamtarbeitszeit von 9,5 Stunden und eine Gesamtpausenzeit von 45 Minuten.

Beachten Sie, dass diese Arbeitszeiten nicht durch Pausen getrennt werden müssen. Es kann auch Arbeitszeiten geben, die einfach aufeinander folgen (Beispiel siehe Testfälle).

Beachten Sie auch, dass Pausen nicht zur Arbeitszeit gehören. Das sind zwei getrennte Werte.

Sie können davon ausgehen, dass die Arbeitszeiten geordnet sind.

Ausgabe

Bei dieser Eingabe wird ein wahrer Wert ausgegeben , wenn genügend Pausen gemacht wurden, und ein falscher Wert, wenn nicht.

Regeln

• Geben Sie das Eingabeformat an, das Sie in Ihrer Übermittlung verwenden.
• Sie müssen keine leeren Eingaben verarbeiten. Es wird immer mindestens eine Arbeitsperiode geben.
• Die Arbeitszeit beträgt nur einen Tag, sodass Sie nicht über Mitternacht arbeiten müssen.
• Date- / Time- / Whatever- Builtins sind erlaubt, solange es mit Ihrer Sprache kommt.
• Funktion oder Vollprogramm erlaubt.
• Standardregeln für die Eingabe / Ausgabe.
• Es gelten Standardlücken .
• Dies ist Code-Golf , also gewinnt die niedrigste Byte-Anzahl. Tie-Breaker ist eine frühere Vorlage.

Testfälle

Gleiches Eingabeformat wie im obigen Beispiel.

[("07:00", "12:00"), ("12:30", "15:30"), ("15:45", "17:15")] -> WAHR // 9: 30h Arbeit, 45 Minuten Pause -> OK
[("07:20", "07:45"), ("07:59", "11:30"), ("11:55", "15:00")] -> FALSE // 7: 01h Arbeit, 39 Minuten Pause, aber die erste Pause zählt nicht, weil <15 Minuten
[("06:00", "09:00"), ("09:00", "11:50")] -> TRUE // Nur 5: 50h arbeiten, also keine Pause nötig
[("07:30", "12:00"), ("12:30", "16:00")] -> WAHR // 8h Arbeitspause, 30 Minuten Pause -> OK
[("08:00", "12:30"), ("13:05", "17:45")] -> FALSE // 9: 10h Arbeit, nur 35 Minuten Pause statt der benötigten 45
[("08:00", "14:00")] -> FALSE // 6h Arbeit, keine Pausen, aber 30 Minuten benötigt

Viel Spaß beim Codieren!

Pyth, 56 52 Bytes

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

Übernimmt Eingaben in Form [[hh,mm], [hh,mm], ...]ohne führende 0s

Erläuterung:

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

Probieren Sie es hier aus

Oder probieren Sie alle Testfälle hier aus

Javascript, 108 106 Bytes

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)

Nimmt ein Array von Arrays. Jedes innere Array hat die Startstunde und -minute sowie die Endstunde und -minute für jede Periode.

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

3 Bytes gespart dank DSM.

Dies ist seit einiger Zeit eine meiner mathematischeren Lösungen.

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)

Hier sind meine Testfälle, es zeigt auch, wie ich den Aufruf der Funktion erwarte.

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