Introdução

Aqui na Alemanha, a decisão sobre horários de trabalho é muito rigorosa. Se você trabalha 6 ou mais horas por dia, deve fazer uma pausa de pelo menos 30 minutos. Se você trabalha 9 horas ou mais, precisa fazer uma pausa de 45 minutos. Se você trabalha menos de 6 horas, não precisa fazer intervalos.

É claro que você pode dividir essas pausas, mas cada parte deve ter pelo menos 15 minutos para ser contada.

O desafio

Neste desafio, você obterá uma lista de períodos de trabalho e precisará verificar se foram feitas pausas suficientes, usando as seguintes regras:

Seja wo tempo de trabalho em horas:

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

Além disso, cada intervalo deve ter pelo menos 15 minutos. Além disso, você sempre pode fazer mais pausas do que o necessário. Esses são todos os valores "pelo menos".

Entrada

Sua entrada será uma lista de períodos de trabalho. O formato exato é com você, mas deve conter apenas valores de tempo como horas e minutos.

Exemplo:

Formato aqui é uma lista de tuplas enquanto cada uma representa um período de trabalho. O primeiro elemento de uma tupla será o horário de início, o segundo será o horário de término.

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

Isso resulta em um tempo total de trabalho de 9,5 horas e um tempo total de pausa de 45 minutos.

Observe que esses períodos de trabalho não precisam ser separados por intervalos. Também pode haver períodos de trabalho que apenas se seguem (exemplo, veja casos de teste).

Observe também que as pausas não contam para o tempo de trabalho. Esses são dois valores separados.

Você pode assumir que os períodos de trabalho estão ordenados.

Resultado

Dada essa entrada, saída de um truthy valor se pausas suficientes foram tomadas e um Falsas valor se não.

Regras

• Especifique o formato de entrada que você está usando no seu envio.
• Você não precisa lidar com entradas vazias. Sempre haverá pelo menos um período de trabalho.
• Os períodos de trabalho duram apenas um dia, para que você não precise lidar com o trabalho durante a meia-noite.
• Data / Hora / Qualquer que seja o recurso permitido, desde que seja fornecido com o seu idioma.
• Função ou programa completo permitido.
• Regras padrão para entrada / saída.
• Aplicam-se brechas padrão .
• Isso é código-golfe , portanto, a menor contagem de bytes vence. O desempate é uma submissão anterior.

Casos de teste

Mesmo formato de entrada que no exemplo acima.

[("07:00", "12:00"), ("12:30", "15:30"), ("15:45", "17:15")] -> TRUE // 9: 30h de trabalho, 45 minutos de intervalo -> OK
[("07:20", "07:45"), ("07:59", "11:30"), ("11:55", "15:00")] -> FALSO // 7: 01h de trabalho, 39 minutos de intervalo, mas o primeiro intervalo não conta porque <15 minutos
[("06:00", "09:00"), ("09:00", "11:50")] -> VERDADEIRO // Apenas 5: 50h de trabalho, portanto, não é necessário interromper
[("07:30", "12:00"), ("12:30", "16:00")] -> VERDADEIRO // 8h de trabalho, 30 minutos de intervalo -> OK
[("08:00", "12:30"), ("13:05", "17:45")] -> FALSO // 9: 10h de trabalho, apenas 35 minutos de pausa em vez dos necessários 45
[("08:00", "14:00")] -> FALSO // 6h de trabalho, sem interrupções, mas são necessários 30 minutos

Feliz codificação!

Pitão, 56 52 bytes

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

Recebe entrada no formulário [[hh,mm], [hh,mm], ...]sem 0s iniciais

Explicação:

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

Experimente aqui

Ou tente todos os casos de teste aqui

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 uma matriz de matrizes. Cada matriz interna possui a hora inicial e o minuto e a hora final e o minuto, 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>'

Python 3, 135

Economizou 3 bytes graças ao DSM.

Esta é uma das minhas soluções matemáticas há algum tempo.

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)

Aqui estão meus casos de teste, também mostra como eu espero que a função seja chamada.

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