introduction

Ici en Allemagne, la décision sur les horaires de travail est très stricte. Si vous travaillez 6 heures ou plus par jour, vous devez prendre au moins 30 minutes de pause. Si vous travaillez 9 heures ou plus, vous devez prendre une pause de 45 minutes. Si vous travaillez moins de 6 heures, vous n'avez pas à faire de pause.

Bien sûr, vous pouvez fractionner ces pauses, mais chaque partie doit durer au moins 15 minutes pour être comptée.

Le défi

Dans ce défi, vous obtiendrez une liste des périodes de travail et vous devrez vérifier si suffisamment de pauses ont été prises, en utilisant les règles suivantes:

Soit wle temps de travail en heures:

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

De plus, chaque pause doit durer au moins 15 minutes. Vous pouvez également toujours prendre plus de pauses que nécessaire. Ce sont toutes des valeurs "au moins".

Contribution

Votre contribution sera une liste de périodes de travail. Le format exact dépend de vous, mais il ne doit contenir que des valeurs horaires comme les heures et les minutes.

Exemple:

Le format est ici une liste de tuples tandis que chaque tuple représente une période de travail. Le premier élément d'un tuple sera l'heure de début, le second sera l'heure de fin.

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

Il en résulte un temps de travail total de 9,5 heures et un temps de pause total de 45 minutes.

Notez que ces périodes de travail ne doivent pas être séparées par des pauses. Il peut aussi y avoir des périodes de travail qui se succèdent (exemple voir cas de test).

Notez également que les pauses ne comptent pas dans le temps de travail. Ce sont deux valeurs distinctes.

Vous pouvez supposer que les périodes de travail sont ordonnées.

Production

Compte tenu de cette entrée, affichez une valeur véridique si suffisamment de pauses ont été prises et une valeur fausse si ce n'est pas le cas.

Règles

• Spécifiez le format d'entrée que vous utilisez dans votre soumission.
• Vous n'avez pas besoin de gérer une entrée vide. Il y aura toujours au moins une période de travail.
• Les périodes de travail ne s'étendent que sur une journée, vous n'avez donc pas à gérer le travail après minuit.
• Date- / Heure- / Peu importe - Les éditions sont autorisées, à condition qu'elles soient fournies avec votre langue.
• Fonction ou programme complet autorisé.
• Règles par défaut pour les entrées / sorties.
• Des échappatoires standard s'appliquent.
• Il s'agit de code-golf , donc le nombre d'octets le plus bas l'emporte. Le bris d'égalité est une soumission antérieure.

Cas de test

Même format d'entrée que dans l'exemple ci-dessus.

[("07:00", "12:00"), ("12:30", "15:30"), ("15:45", "17:15")] -> TRUE // 9: 30h de travail, 45 minutes de pause -> OK
[("07:20", "07:45"), ("07:59", "11:30"), ("11:55", "15:00")] -> FAUX // 7: 01h de travail, 39 minutes de pause, mais la première pause ne compte pas car <15 minutes
[("06:00", "09:00"), ("09:00", "11:50")] -> TRUE // Seulement 5: 50h de travail, donc pas de pause nécessaire
[("07:30", "12:00"), ("12:30", "16:00")] -> TRUE // 8h de travail, 30 minutes de pause -> OK
[("08:00", "12:30"), ("13:05", "17:45")] -> FAUX // 9: 10h de travail, seulement 35 minutes de pause au lieu des 45 nécessaires
[("08:00", "14:00")] -> FAUX // 6h de travail, pas de pause, mais 30 minutes nécessaires

Codage heureux!

Pyth, 56 52 octets

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

Prend la saisie dans le formulaire [[hh,mm], [hh,mm], ...]sans 0s

Explication:

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

Essayez-le ici

Ou essayez tous les cas de test ici

Javascript, 108 106 octets

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)

Prend un tableau de tableaux. Chaque tableau interne a respectivement l'heure et la minute de début et l'heure et la minute de fin pour chaque période.

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

Enregistré 3 octets grâce à DSM.

C'est une de mes solutions mathématiques depuis longtemps.

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)

Voici mes cas de test, il montre également comment je m'attends à ce que la fonction soit appelée.

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