introduzione

Qui in Germania la sentenza sull'orario di lavoro è molto severa. Se lavori 6 o più ore al giorno, devi fare almeno una pausa di 30 minuti. Se lavori 9 o più ore, devi fare una pausa di 45 minuti. Se lavori per meno di 6 ore, non devi fare pause.

Ovviamente puoi dividere quelle pause, ma ogni parte deve essere lunga almeno 15 minuti per essere contata.

La sfida

In questa sfida otterrai un elenco di periodi di lavoro e dovrai verificare se sono state prese abbastanza pause, usando le seguenti regole:

Lascia che wsia il tempo di lavoro in ore:

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

Inoltre, ogni pausa deve durare almeno 15 minuti. Inoltre puoi sempre fare più pause del necessario. Questi sono tutti valori "almeno".

Ingresso

Il tuo contributo sarà un elenco di periodi di lavoro. Il formato esatto dipende da te, ma deve contenere solo valori di tempo come ore e minuti.

Esempio:

Il formato qui è un elenco di tuple mentre ogni tupla rappresenta un periodo di lavoro. Il primo elemento in una tupla sarà l'ora di inizio, il secondo sarà l'ora di fine.

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

Ciò si traduce in un tempo di lavoro totale di 9,5 ore e un tempo di pausa totale di 45 minuti.

Si noti che tali periodi di lavoro non devono essere separati da interruzioni. Possono esserci anche periodi lavorativi che si susseguono reciprocamente (esempio vedi casi di test).

Si noti inoltre che le pause non contano nell'orario di lavoro. Questi sono due valori separati.

Si può presumere che i periodi lavorativi siano ordinati.

Produzione

Dato questo input, genera un valore di verità se sono state prese abbastanza pause e un valore di falsa in caso contrario.

Regole

• Specificare il formato di input che si sta utilizzando nell'invio.
• Non è necessario gestire input vuoti. Ci sarà sempre almeno un periodo di lavoro.
• I periodi di lavoro dureranno solo un giorno, quindi non dovrai gestire il lavoro oltre la mezzanotte.
• Data / ora / qualunque cosa sono consentiti, purché vengano forniti con la tua lingua.
• Funzione o programma completo consentiti.
• Regole predefinite per input / output.
• Si applicano scappatoie standard .
• Questo è code-golf , quindi vince il conteggio dei byte più basso. Il pareggio è presentazione precedente.

Casi test

Stesso formato di input dell'esempio sopra.

[("07:00", "12:00"), ("12:30", "15:30"), ("15:45", "17:15")] -> TRUE // 9: 30 ore di lavoro, 45 minuti di pausa -> OK
[("07:20", "07:45"), ("07:59", "11:30"), ("11:55", "15:00")] -> FALSE // 7: 01 ore di lavoro, 39 minuti di pausa, ma la prima pausa non conta perché <15 minuti
[("06:00", "09:00"), ("09:00", "11:50")] -> TRUE // Solo 5: 50 ore di lavoro, quindi non è necessaria alcuna pausa
[("07:30", "12:00"), ("12:30", "16:00")] -> TRUE // 8 ore di lavoro, 30 minuti di pausa -> OK
[("08:00", "12:30"), ("13:05", "17:45")] -> FALSE // 9: 10 ore di lavoro, solo 35 minuti di pausa invece dei 45 necessari
[("08:00", "14:00")] -> FALSE // 6 ore di lavoro, nessuna pausa, ma sono necessari 30 minuti

Buona programmazione!

Pyth, 56 52 byte

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

Accetta input nel modulo [[hh,mm], [hh,mm], ...] senza 0s iniziali

Spiegazione:

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

Provalo qui

Oppure prova tutti i casi di test qui

Javascript, 108 106 byte

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)

Accetta una serie di array. Ogni array interno ha l'ora e il minuto di inizio e l'ora e i minuti di fine rispettivamente per ciascun periodo.

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

Salvato 3 byte grazie a DSM.

Questa è una delle mie soluzioni matematiche da un po '.

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)

Ecco i miei casi di test, mostra anche come mi aspetto che venga chiamata la funzione.

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