Introducción

Aquí en Alemania, la decisión sobre los horarios de trabajo es muy estricta. Si trabaja 6 o más horas al día, debe tomarse un descanso de al menos 30 minutos. Si trabaja 9 horas o más, debe tomar un descanso de 45 minutos. Si trabaja menos de 6 horas, no tiene que tomar descansos.

Por supuesto, puede dividir esos descansos, pero cada parte debe tener al menos 15 minutos para contar.

El reto

En este desafío, obtendrá una lista de períodos de trabajo y deberá verificar si se tomaron suficientes descansos, utilizando las siguientes reglas:

Sea wel tiempo de trabajo en horas:

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

Además, cada descanso debe durar al menos 15 minutos. Además, siempre puede tomar más descansos de los necesarios. Esos son todos los valores "al menos".

Entrada

Su entrada será una lista de períodos de trabajo. El formato exacto depende de usted, pero debe contener solo valores de tiempo como horas y minutos.

Ejemplo:

El formato aquí es una lista de tuplas, mientras que cada tupla representa un período de trabajo. El primer elemento en una tupla será la hora de inicio, el segundo será la hora de finalización.

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

Esto da como resultado un tiempo de trabajo total de 9,5 horas y un tiempo de descanso total de 45 minutos.

Tenga en cuenta que esos períodos de trabajo no tienen que estar separados por descansos. También puede haber períodos de trabajo que simplemente se siguen (ver ejemplos de casos de prueba).

También tenga en cuenta que los descansos no cuentan en el tiempo de trabajo. Esos son dos valores separados.

Puede suponer que los períodos de trabajo están ordenados.

Salida

Dada esta entrada, genera un valor verdadero si se tomaron suficientes descansos y un valor falso si no.

Reglas

• Especifique el formato de entrada que está utilizando en su envío.
• No tiene que manejar entradas vacías. Siempre habrá al menos un período de trabajo.
• Los períodos de trabajo solo durarán un día, por lo que no tiene que manejar el trabajo durante la medianoche.
• Fecha- / Hora- / Lo que sea- Builtins permitido, siempre que venga con su idioma.
• Función o programa completo permitido.
• Reglas predeterminadas para entrada / salida.
• Se aplican lagunas estándar .
• Este es el código de golf , por lo que gana el conteo de bytes más bajo. El desempate es la presentación anterior.

Casos de prueba

Mismo formato de entrada que en el ejemplo anterior.

[("07:00", "12:00"), ("12:30", "15:30"), ("15:45", "17:15")] -> VERDADERO // 9: 30h de trabajo, 45 minutos de descanso -> OK
[("07:20", "07:45"), ("07:59", "11:30"), ("11:55", "15:00")] -> FALSO // 7: 01h de trabajo, 39 minutos de descanso, pero el primer descanso no cuenta porque <15 minutos
[("06:00", "09:00"), ("09:00", "11:50")] -> VERDADERO // Solo 5: 50h de trabajo, por lo que no se necesita descanso
[("07:30", "12:00"), ("12:30", "16:00")] -> VERDADERO // 8h de trabajo, 30 minutos de descanso -> OK
[("08:00", "12:30"), ("13:05", "17:45")] -> FALSO // 9: 10h de trabajo, solo 35 minutos de descanso en lugar de los 45 necesarios
[("08:00", "14:00")] -> FALSO // 6h de trabajo, sin descansos, pero se necesitan 30 minutos

¡Feliz codificación!

Pyth, 56 52 bytes

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

Toma entrada en el formulario [[hh,mm], [hh,mm], ...]sin 0s

Explicación:

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

Pruébalo aquí

O prueba todos los casos de prueba aquí

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)

Toma una matriz de matrices. Cada conjunto interno tiene la hora y minuto de inicio y la hora y minuto de finalización respectivamente para cada período.

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>'

Pitón 3, 135

Guardado 3 bytes gracias a DSM.

Esta es una de mis soluciones matemáticas en mucho tiempo.

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)

Aquí están mis casos de prueba, también muestra cómo espero que se llame a la función.

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