Feuilles de temps

Dans un lieu de travail, vous devez souvent remplir des feuilles de temps. Cette tâche consiste à écrire du code pour y parvenir.

Contribution

Deux fois dans une horloge de 12 heures légèrement non standard indiquant le début et la fin de la journée séparés par un espace. Un troisième chiffre représente le nombre de minutes prises pour le déjeuner. Par exemple

9:14 5:12 30

Cela signifie que vous avez commencé le travail à 9 h 14, terminé le travail à 17 h 12 et pris 30 minutes pour le déjeuner.

Vous pouvez supposer que

• Toute heure dans la première colonne est de 00h00 (minuit) jusqu'à 13h00 (heure non incluse) et toute heure dans la deuxième colonne est de 13h00 au plus tôt jusqu'à 23h59.
• La pause déjeuner n'est pas plus longue que la journée de travail!

Le format d'entrée doit être comme dans les exemples donnés.

Tâche

Votre code doit lire dans un fichier (ou une entrée standard) de ces triplets, et pour chacun afficher combien de temps vous avez travaillé. Cette sortie doit indiquer le nombre d'heures. Pour l'exemple ci-dessus, c'est:

7h et 58min moins 30 minutes soit 7h 28min.

Production

Votre sortie doit spécifier le nombre (entier) d'heures et de minutes et ne doit pas énumérer plus de 59 minutes. Autrement dit, vous ne pouvez pas sortir 2h 123min. En dehors de cela, votre code peut sortir dans n'importe quel format facilement lisible par l'homme qui vous convient.

Exemples

10:00 1:00 30    --> 2hr 30min
12:59 1:00 0     --> 0hr 1min
00:00 11:59 0    --> 23hr 59min
10:00 2:03 123   --> 2hr 0min 

MATL , 28 octets

`jYb0&)YOd.5+wgU13L/- 15XODT

Essayez-le en ligne!

Retina 0.8.2 , 83 octets

\d+
$*
 (1+:)
 12$*1$1
+`1:
:60$*
(1*) :\1(1*)(1*) \2
$3
:(1{60})*(1*)
$#1hr $.2min

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

\d+
$*

Convertissez l'entrée en unaire.

 (1+:)
 12$*1$1

Ajoutez 12 heures à l'heure d'arrêt.

+`1:
:60$*

Multipliez les heures par 60 et ajoutez aux minutes.

(1*) :\1(1*)(1*) \2
$3

Soustrayez l'heure de début et l'heure de pause de l'heure d'arrêt.

:(1{60})*(1*)
$#1hr $.2min

Divmod par 60. (Économisez 5 octets pour un format de sortie plus ennuyeux.)

Perl 5 -pl, 80 74 71 octets

/:(\d+) (\d+):(\d+) /;$m=720+($2-$`)*60+$3-$1-$';$_=($m/60|0).":".$m%60

Essayez-le en ligne!

Python 3, 161 octets

Je sais que cela ne sera même pas proche du plus petit, mais cela se lit dans un fichier:

for l in open('t'):
    l=l[:-1].split(':')
    m=-int(l[0])*60+int(l[1][:2])+(int(l[1][3:])*60+720+int(l[2][:2])-int(l[2][2:]))
    print(f'{m//60}hr {m-(m//60*60)}min')

Je ressens l'ironie de faire une pause dans ma feuille de temps pour faire ça ...

Python 2.7, 133 octets

Merci pour les suggestions dans les commentaires! Le passage à python 2.7 permet d'économiser quelques octets supplémentaires car il est par défaut en division entière:

for l in open('t'):i,h,l=int,60,l[:-1].split(':');m=-i(l[0])*h+i(l[1][:2])+(i(l[1][3:])*h+720+i(l[2][:2])-i(l[2][2:]));print m/h,m%60

La même approche avec python3 est de 135 octets en raison de l'instruction print et de la division flottante par défaut:

for l in open('t'):i,h,l=int,60,l[:-1].split(':');m=-i(l[0])*h+i(l[1][:2])+(i(l[1][3:])*h+720+i(l[2][:2])-i(l[2][2:]));print(m//h,m%60)

C, 105 octets

a,b,c,d,e;f(){for(;scanf("%d:%d%d:%d%d",&a,&b,&c,&d,&e);)a=(12+c-a)*60+d-b-e,printf("%d:%d ",a/60,a%60);}

Complètement simple. Essayez-le en ligne ici .

Non golfé:

a, b, c, d, e; // start hours, minutes; end hours, minutes; break - all implicitly int
f() { // function - return type is implicitly int (unused)
    for(; scanf("%d:%d%d:%d%d", &a, &b, &c, &d, &e) ;) // until EOF is hit, read line by line
        a = (12 + c - a) * 60 + d - b - e, printf("%d:%d,", a / 60, a % 60); // calculate the minutes and store, then output separated: "h m"
}

Wolfram Langue 125 119 111 octets

i=Interpreter;j=IntegerPart;Row@{j[t=(i["Time"][#2<>"pm"]-i["Time"][#])[[1]]-#3/60],"hr ",j[60Mod[t,1]],"min"}&

8 octets enregistrés grâce à l'utilisateur 202729

Exemple

Les abréviations ne sont pas utilisées ici, pour faciliter le suivi de la logique.

Row[{IntegerPart[
 t = (Interpreter["Time"][#2 <> "pm"] - 
      Interpreter["Time"][#])[[1]] - #3/60], "hr ",
IntegerPart[60 Mod[t,1]], "min"}] &["9:00", "4:12", 20]

6 h 51 min

Interpreter["Time"][#2 <> "pm"] interprète comme un temps le deuxième paramètre suivi de "pm", à savoir, dans ce cas, "4:12 pm", renvoyant un TimeObjectcorrespondant à 4:12 pm.

-Interpreter["Time"][# <> "am"])[[1]] - #3/60]. #3est le troisième paramètre, à savoir 20min. Le signe moins soustrait l'intervalle de l'heure du déjeuner de la fin du quart de travail. Il renvoie l'heure de fin de quart ajustée, c'est-à-dire la fin de quart qui s'appliquerait si la personne n'avait pas pris de pause déjeuner.

Interpreter["Time"][#] interprète comme une heure le premier paramètre, dans ce cas, "9:00", renvoyant un TimeObjectcorrespondant à 9:00 am.

En soustrayant le début du quart de la fin du temps de quart ajusté t, l'intervalle de temps exprimé en heures. IntegerPart[t]renvoie le nombre d'heures complètes travaillées. IntegerPart[60 Mod[t,1]], "min"}]renvoie les minutes supplémentaires travaillées.

JavaScript, 83 octets 76 octets

s=>(r=s.match(/\d+/g),r=(r[2]-r[0]+12)*60-r[4]-r[1]+ +r[3],(r/60|0)+':'+r%60)

Je viens de me débarrasser de la fonction intérieure de la solution ci-dessous (à quoi pensais-je?). Modification du format de sortie également.

Essayez-le en ligne!

ANCIEN: JavaScript, 112 octets 111 octets 110 octets

s=>(t=(h,m,a)=>(a?12+h:h)*60+m,r=s.match(/\d+/g),r=t(+r[2],r[3]-r[4],1)-t(r[0],+r[1]),`${r/60|0}hr ${r%60}min`)

Explication:

À l'intérieur de la fonction principale, nous commençons par en définir une autre qui nous aidera à calculer les minutes d'un temps donné, en ajoutant 12 heures au paramètre des heures si le troisième paramètre est véridique:

(hours, minutes, addTwelve) =>
    (addTwelve? hours + 12: hours) * 60 + minutes

Ensuite, nous séparons la chaîne par ' 'ou':' correspondons aux nombres à l'intérieur de la chaîne, ce qui donne un tableau de tous les nombres de la chaîne.

Ensuite, nous calculons la différence entre l'heure de fin et l'heure de début et en soustrayant l'heure du déjeuner à l'aide de la fonction définie précédemment (conversion des chaînes en nombres si nécessaire).

Enfin, nous produisons la chaîne de résultat: les heures sont la partie entière de r/60et les minutes sont r%60.

Essayez-le en ligne!

Python 2 , 100 octets

for I in open('x'):x,y,z,w,l=map(int,I.replace(':',' ').split());d=60*(12+z-x)+w-y-l;print d/60,d%60

Essayez-le en ligne!

Programme complet qui lit plusieurs lignes d'un fichier texte, comme indiqué par OP. Une fonction qui analyse simplement une seule ligne permettrait d'économiser un supplément de 10 octets.

Java 10, 194 191 octets

u->{var s=new java.util.Scanner(System.in).useDelimiter("\\D");for(int i,a[]=new int[5];;i=(12+a[2]-a[0])*60+a[3]-a[1]-a[4],System.out.println(i/60+":"+i%60))for(i=0;i<5;)a[i++]=s.nextInt();}

Les E / S sont douloureuses en Java. Se termine anormalement lorsqu'il n'y a pas de ligne d'entrée suivante à lire. Essayez-le en ligne ici .

Non golfé:

u -> { // lambda taking a dummy input – we're not using it, but it saves a byte
var s = new java.util.Scanner(System.in).useDelimiter("\\D"); // we use this to read integers from standard input; the delimiter is any character that is not part of an integer
for(int i, a[] = new int[5]; ; // infinite loop; i will be used to loop through each line and to store the result in minutes between lines; a will hold the inputs
    i = (12 + a[2] - a[0]) * 60 + a[3] - a[1] - a[4], // after each line, calculate the result in minutes ...
    System.out.println(i / 60 + ":" + i % 60)) // ... and output the result in hours:minutes, followed by a newline
    for(i = 0; i < 5; ) // read the five integers on the current line ...
        a[i++] = s.nextInt(); // ... into the array
}

Rouge , 35 octets

func[s e l][e + 12:0 - s -(l * 60)]

Essayez-le en ligne!

Remarque: la sortie est au format hh:mm:ss

R , 97 octets

s=matrix(strtoi(unlist(strsplit(scan(,""),':'))),5,,T)%*%c(-60,-1,60,1,-1);paste(12+s%/%60,s%%60)

Essayez-le en ligne!

Pour chaque ligne retourne "hours minutes"

• -16 octets grâce à JayCe!