Mon réveil

Je suis américain, tout comme mon réveil (numérique). Pour régler l'alarme, elle démarre à l'heure qu'elle était précédemment. Appuyer sur le bouton des heures le fait monter d'une heure et appuyer sur le bouton des minutes le fait monter d'une minute. Appuyer sur les deux boutons en même temps le réinitialise à minuit (00h00) et compte comme deux pressions de bouton.

Lorsque les heures dépassent leur cap (12), il se remet à 1 et fait basculer la lumière AM / PM. Lorsque les minutes dépassent leur cap (59), elles se remettent à 0, sans affecter les heures.

La tâche

Votre tâche consiste, compte tenu d'une heure de début et d'une heure cible, à sortir le nombre optimal de pressions de boutons nécessaires pour régler mon alarme sur l'heure cible.

Vous pouvez saisir des informations dans le format qui vous convient le mieux. Les seules données dont votre programme devrait avoir besoin sont les heures et les minutes, pour les deux entrées. Cela signifie que vous, par exemple, pouvez prendre des données en millisecondes depuis l'époque et extraire les heures et les minutes, mais vous ne pouvez pas encoder quoi que ce soit en année, mois, seconde, etc. Notez que si vous pouvez, par exemple, saisir en utilisant "heure militaire" (ou heure régulière pour la plupart du monde), mais cela ne change pas le fonctionnement de mon horloge.

Exemples

1:15 pm -> 2:30 am

Vous pouvez appuyer sur les deux boutons pour réinitialiser à 12 h 00, puis augmenter à 2 h 30, ce qui correspond à des 2+2+30 = 34pressions sur les boutons. Vous pouvez également augmenter jusqu'à 2 h 30, ce qui correspond à des 13+15 = 28pressions sur des boutons. Par conséquent, votre sortie est 28.

3:58 am -> 4:02 am

Vous pouvez réinitialiser et incrémenter, ce qui correspond à des 2+4+2 = 8pressions sur des boutons. Vous pouvez également augmenter, ce qui serait des 1+4 = 5appuis sur les boutons. Par conséquent, votre sortie est 5.

10:55 pm -> 1:00 am

Vous pouvez réinitialiser et incrémenter, ce qui correspond à des 2+1 = 3pressions sur des boutons. Vous pouvez également augmenter, ce qui serait des 3+5=8appuis sur les boutons. Par conséquent, votre sortie est 3.

1:00 am -> 1:59 pm

Vous pouvez réinitialiser et incrémenter, mais ce serait trois pressions de plus que l'incrémentation. Par conséquent, votre sortie est 12+59 = 71.

Cas de test

Current  Target   = Output
1:15pm   2:30am   = 28
3:58am   4:02am   = 5
10:55pm  1:00am   = 3
1:00am   1:59pm   = 71
12:00am  12:00am  = 0
6:51pm   12:00am  = 2
2:01pm   11:00pm  = 25
2:01pm   11:01pm  = 9
12:59am  12:01am  = 2
11:50am  12:00pm  = 11

Husk , 16 octets

§▼ṁ→(Σz%e24 60z-

Essayez-le en ligne!

Prend les arguments sous forme de deux listes [heures, minutes], pour les heures de début et de fin, au format 24h.

Je suis assez content de voir à quel point j'ai pu jouer à celui-ci, je trouve intéressant de voir comment les arguments sont gérés dans cette composition de fonctions.

La fonction qui calcule le nombre de touches dont nous avons besoin si la réinitialisation n'est pas autorisée est la suivante:

Σz%e24 60z-
         z-    elementwise subtract the two times
 z%e24 60      take the hours difference modulo 24 and the minutes difference modulo 60
Σ              sum the two resulting numbers

La partie intéressante est que, comme le reste de cette solution ne peut fonctionner qu'avec une seule liste comme argument, celui-ci est partiellement appliqué au premier argument de tout le programme, le "mangeant" et ne laissant que le deuxième argument visible à la fois pour lui-même et le reste du programme.

Ensuite, nous calculons le nombre d'appuis sur les touches dont nous avons besoin si nous remettons l'heure à 0:00.

ṁ→    take the sum of each element of the list increased by 1

Comme dit précédemment, cela ne fonctionne que sur le deuxième argument (la dernière fois), et calcule hours+minutes+2, juste de manière golfique.

Enfin, §▼c'est la partie qui transmet le deuxième argument aux deux fonctions et renvoie le moindre des deux résultats.

JavaScript (ES6), 73 56 54 52 50 octets

Utilise le format 24 heures. Prend l'entrée comme 4 entiers représentant les heures et les minutes de chaque fois.

(g,l,h,m)=>Math.min(2+h+m,(h-g+24)%24+(m-l+60)%60)

• 2 octets enregistrés grâce à Arnauld .

Essayez-le

Entrez les heures au format 24 heures, avec le :séparateur.

o.innerText=(f=

(g,l,h,m)=>Math.min(2+h+m,(h-g+24)%24+(m-l+60)%60)

)(+(x=(i.value="01:00").split`:`)[0],+x[1],+(y=(j.value="13:59").split`:`)[0],+y[1]);oninput=_=>o.innerText=f(+(x=i.value.split`:`)[0],+x[1],+(y=j.value.split`:`)[0],+y[1])

label,input{font-family:sans-serif;font-size:14px;height:20px;line-height:20px;vertical-align:middle}input{margin:0 5px 0 0;width:100px;}

<label for=i>Current: </label><input id=i type=time><label for=j>Target: </label><input id=j type=time><pre id=o>

Explication

(À mettre à jour sous peu.)

(g,l,h,m)=>

Fonction anonyme en prenant les nombres entiers comme arguments au moyen des paramètres g, l, het m, le cas g& lsont, respectivement, les heures et les minutes du temps courant et h& msont les heures et les minutes du temps cible.

2+h+m

Tout d'abord, nous calculons le nombre de pressions de bouton nécessaires si nous venons de réinitialiser l'horloge, qui est simplement 2 (pour la réinitialisation) plus l'heure cible et la minute cible.

h-g+24*(h<g)

Ensuite, nous calculons le nombre de pressions de bouton nécessaires pour atteindre l'heure cible. Nous faisons cela en soustrayant l'heure actuelle de l'heure cible. Cependant, si l'heure actuelle est inférieure à la cible, cela nous donnera un nombre négatif, nous rectifions donc cela en ajoutant 24 multiplié en vérifiant si h<g(qui renvoie un booléen mais est implicitement converti en entier 1, si vrai, ou 0si faux par le opérations mathématiques.

+m-l+60*(m<l)

Nous utilisons une formule similaire pour calculer le nombre de presses pour passer de la minute actuelle à la minute cible et l'ajouter aux presses horaires.

Math.min()

Enfin, nous obtenons le minimum des 2 nombres pour nous donner notre résultat.

Pyth , 29 octets

Ce défi ne profite évidemment pas aux langues de golf, c'est pourquoi il est si long. D'un autre côté, cela est amélioré par le fait que Pyth est basé sur Python, donc nous pouvons abuser de son module négatif.

hS,+%-eQ@Q1 60%-@Q2hQ24+2s>Q2

Suite de tests. _{Les nombres en Pyth ne prennent pas en charge les zéros non significatifs.}

Gelée , 19 octets

_⁵%24µ+⁴_⁶%60µ«³+⁴¤

Essayez-le en ligne!

Entrée sous forme de 4 entiers (heure de fin, minute de fin, heure de début, minute de début)

C # (.NET Core) , 56 octets

(H,M,h,m)=>Math.Min(((h+24-H)%24)+((m+60-M)%60),(2+h+m))

Essayez-le en ligne!

Très similaire à la réponse Javascript. Les bogues en C # ne se convertissent pas facilement en nombres, donc au lieu de [diff]+24*(H<h)je l'ai fait, ([diff]+24)%24ce qui fait effectivement la même chose.

Haskell, 41 octets

(a#b)c d=min(a+b+2)$mod(a-c)24+mod(b-d)60

Assez simple. Prend l'entrée comme quatre arguments en utilisant une heure de 24 heures: heure de fin, minute de fin, heure de début, minute de début.

Python 3 , 43 octets

lambda a,b,c,d:min((c-a)%24+(d-b)%60,2+c+d)

Essayez-le en ligne!

Entrée sous forme de 4 entiers (heure de début, minute de début, heure de fin, minute de fin)

Java 8, 54 50 octets

(h,m,H,M)->Math.min((H-h+24)%24+(M-m+60)%60,H+M+2)

Port de la réponse C # de @KamilDrakari (après avoir joué au golf 2 6 octets).

Explication:

Essayez-le ici.

(h,m,H,M)->       // Method with four integer parameter and integer return-type
  Math.min(       //  Return the lowest of the following two:
                  //   The hours:
   (H-h           //    Second hours - first hours inputs
       +24)       //    +24 so we won't have negative numbers
           %24    //    mod-24 to get the hours
   +              //   And add the minutes:
    (M-m          //    Second minutes - first minutes inputs
         +60)     //    +60 so we won't have negative numbers
             %60  //    mod-60 to get the minutes
    ,H+M          //  And compare it to the second hours + second minutes inputs
        +2)       //   +2 for the added +24 and +60 to get the positive modulo arguments

Perl 5 , 71 +2 (-ap) = 73 octets

($w,$x,$y,$z)=@F;$_=($r=2+$y+$z)>($c=($y-$w+24)%24+($z-$x+60)%60)?$c:$r

Essayez-le en ligne!

Prend les données au format 24 heures (heure militaire), séparées par des espaces, heure de début en premier, heure de fin en second: HH MM hh mm

Rétine , 106 octets

\d+
$*
 (1*):(1*)
 24$*1$1:60$*1$2#11$1$2
(1*):(1* )\1(1{24})?
$2
(1*) (1*):\1(1{60})?
$2
(1+)#(?!\1)

\G1

Essayez-le en ligne! Le lien inclut des cas de test. Prend les entrées en tant qu'heures actuelles et souhaitées en 24 heures régulières avec un espace séparant les deux heures. Explication:

\d+
$*

Convertissez en unaire.

 (1*):(1*)
 24$*1$1:60$*1$2#11$1$2

Cela fait deux choses; il ajoute 24 heures et 60 minutes aux heures et minutes souhaitées, et il ajoute également 2 à la somme des heures et des minutes souhaitées d'origine, c'est-à-dire le nombre d'appuis sur les boutons à régler à l'aide d'une réinitialisation.

(1*):(1* )\1(1{24})?
$2

Soustrayez les heures actuelles des heures souhaitées et soustrayez les 24 que nous avons ajoutées si nous le pouvons.

(1*) (1*):\1(1{60})?
$2

De même pour les minutes. Cela ajoute également les deux résultats ensemble.

(1+)#(?!\1)

Si le nombre de pressions à régler à l'aide de l'heure actuelle est supérieur au nombre de pressions à régler à l'aide d'une réinitialisation, supprimez-le.

\G1

Convertissez le premier nombre restant en décimal.