J'ai un vieux réveil stupide avec deux boutons: houret minute. Le hourbouton incrémente l'heure d'une alarme définie et minuteincrémente l'heure des minutes d'une alarme définie. Cependant, certains designers intelligents réalisé que sur les deux boutons en même temps doit avoir un sens, et a décidé que l' appui houret minuteserait en même temps peuvent déclencher l'alarme être réglée sur 12:00 am/ 0:00. Votre tâche consiste à simuler ce comportement.

Tâche

Étant donné une heure de début et une séquence d'états de bouton, déterminez l'heure de fin.

À partir de l'heure de début, incrémentez l'heure pour chaque occurrence de (1,0), incrémentez la minute pour chaque occurrence de (0,1)et réglez l'heure sur 0:00pour chaque occurrence de (1,1). Les états (0,0)doivent être ignorés car ils ne correspondent à aucun bouton pressé.

Lors de l'ajout aux minutes et aux heures, si la minute / heure dépasse le maximum, réglez-la sur 0, c'est- à -dire que l'incrémentation d'une valeur de minute de 59devrait définir la valeur de minute à 0et l'incrémentation d'une valeur d'heure de 23devrait définir la valeur de l'heure à 0. L'incrémentation des valeurs minute / heure au-dessus de leurs limites n'affecte pas l'autre valeur, par exemple l'incrémentation de la minute des 10:59rendements 10:00, non 11:00.

Exemple

Compte tenu du temps 13:58et des étapes de saisie [(0,1),(0,1),(0,1),(0,0),(1,1),(1,0)],

1. (0,1). Cela correspond à minuteune pression. Le moment est venu 13:59.
2. (0,1). Cela correspond à minuteune pression. Le moment est venu 13:00.
3. (0,1). Cela correspond à minuteune pression. Le moment est venu 13:01.
4. (0,0). Cela correspond à aucun bouton pressé. Le temps, inchangé, est maintenant13:01
5. (1,1). Cela correspond à la pression des deux boutons. Le moment est venu 0:00.
6. (1,0)Cela correspond à hourune pression. Le moment est venu 1:00.

Puisque nous terminons avec 1:00, c'est la sortie.

E / S

L'entrée consistera en un temps et une séquence d'états de bouton. La sortie est une seule fois.

Le temps d'entrée et le temps de sortie peuvent être

• un temps de 2 tuple (hour, minute)ou (minute, hour)en 24heures tel que (13, 30)( hourvarie de 0à 23et minutevarie de 0à 59)
• identique à l' 12heure précédente mais en heure et un booléen am/ pmswitch ( hourvarie de 0à 11ou 12et 1à 11avec minutede 0à 59).
• un certain nombre de minutes depuis 0:00comme le 810 (de 0 à 1439 inclus)
• tout autre format codant les mêmes informations

La séquence des états des boutons est une représentation d'une liste de 2-tuples booléens, par exemple:

• une liste de tuples: [(0,1),(1,0),(0,0),(1,1)]
• une chaîne délimitée par des espaces: "01 10 00 11"
• un string: "01100011"
• au Quaternaire: [1,2,0,3]
• converti en entier: 99
• tout autre format codant les mêmes informations

Cas de test

time,steps -> output
06:49,[(0, 1)] -> 06:50
12:23,[(1, 0)] -> 13:23
02:23,[(0, 1), (1, 0)] -> 03:24
21:40,[(0, 1), (0, 1), (0, 1), (0, 1)] -> 21:44
13:10,[(0, 1), (0, 1), (0, 1), (0, 1), (1, 0), (1, 1), (0, 1), (0, 1)] -> 00:02
21:33,[(1, 0), (0, 1), (1, 0), (0, 1)] -> 23:35
14:21,[(0, 1), (0, 1), (0, 1)] -> 14:24
02:39,[(0, 0), (0, 1)] -> 02:40
16:07,[(0, 1), (0, 1), (0, 1), (0, 1), (1, 0), (1, 0), (0, 1), (0, 1), (1, 0), (0, 1), (0, 1), (0, 1)] -> 19:16
17:55,[(0, 1), (1, 0), (0, 1)] -> 18:57
15:55,[(1, 0), (1, 0), (1, 0), (0, 1), (0, 1), (0, 1), (1, 0), (1, 0), (0, 1), (1, 0), (1, 0), (0, 1), (1, 0)] -> 23:00
22:11,[(0, 1), (1, 0), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (1, 0), (0, 1), (0, 1)] -> 00:19
03:58,[(1, 0), (0, 0), (0, 0), (0, 1), (0, 1), (1, 0), (1, 0), (0, 1), (0, 1), (1, 0), (0, 1)] -> 07:03
13:02,[(0, 1), (1, 0), (0, 1), (1, 0), (0, 1), (0, 1), (1, 0)] -> 16:06
04:37,[(1, 0), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (1, 0), (0, 1), (1, 0), (0, 1), (1, 0)] -> 08:47
00:01,[(0, 1), (1, 0), (1, 0), (0, 1), (0, 1), (0, 1), (1, 0), (0, 1), (0, 1), (0, 1)] -> 03:08
02:58,[(1, 0), (1, 0), (0, 1)] -> 04:59
01:43,[(0, 1), (0, 1), (1, 0), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (1, 0), (0, 1), (1, 0), (0, 1)] -> 04:52
07:54,[(1, 0), (0, 1), (1, 0), (1, 0), (1, 1)] -> 00:00
09:33,[(0, 1), (0, 1), (0, 1), (1, 0), (0, 1), (0, 1)] -> 10:38
09:01,[(0, 1), (0, 1)] -> 09:03
19:04,[(0, 1), (1, 0), (0, 1), (1, 0)] -> 21:06
11:17,[(0, 1), (1, 0), (0, 1), (0, 1), (1, 0), (0, 1), (0, 1), (1, 1), (0, 1), (0, 1)] -> 00:02
19:32,[(0, 1), (1, 0), (0, 1), (1, 0), (1, 0), (1, 0)] -> 23:34
17:31,[(0, 1), (0, 1), (0, 1), (1, 0), (0, 1), (1, 0), (0, 1), (0, 0), (1, 1), (0, 1)] -> 00:01
06:46,[(0, 1), (0, 1), (0, 1), (0, 1), (1, 0), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (1, 0), (0, 1), (0, 1), (1, 0), (1, 0), (0, 1), (0, 1), (0, 1), (1, 0), (1, 0), (0, 1), (0, 1), (0, 1), (1, 0), (0, 1), (1, 0), (0, 1), (0, 1), (1, 0), (0, 1), (0, 1), (0, 1), (1, 0), (1, 0), (0, 1), (1, 0), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1)] -> 18:16

Gelée , 13 octets

_`+Ạ}?/%24,60

Essayez-le en ligne!

C, 89 87 octets

Merci à @Jonathan Frech d'avoir économisé deux octets!

f(h,m,s)char*s;{for(;*s;++s)*s++&1?*s&1?h=m=0:++h:*s&1&&++m;printf("%d %d",h%24,m%60);}

Essayez-le en ligne!

Gelée ,  21  (17?) 19 octets

^{17 octets? - Si le format d'entrée: [[initHour, initMinute], [a1, b1], [a2, b2], ...]est acceptable, nous aurions un lien monadique et nous pourrions le supprimerW; au début de la deuxième ligne.}

Remarque: Cela converge maintenant vers la réponse d'Erik the Outgolfers Jelly , donc je ne prendrai plus la peine de jouer au golf (je ne l'avais pas vu) ...

N⁹⁹Ạ¤?+⁸
W;ç/%24,60

Un lien dyadique prenant une liste de l'heure initiale sous forme d'entiers [hour, minute](24 heures) à gauche et une liste d'états de bouton [[hourPressed, minPressed], ...]à droite
qui renvoie une liste de l'heure de résultat final sous forme d'entiers, encore une fois [hour, minute](24 heures).

Essayez-le en ligne! ou voir la suite de tests

Comment?

N⁹⁹Ạ¤?+⁸ - Link 1, nextState: list, currentState [cH, cM]; list, presses [pH, pM]
     ?   - if:
    ¤    - ...condition: nilad followed by link(s) as a nilad:
  ⁹      -   chain's right argument, presses
   Ạ     -   all truthy? (1 for [1,1] 0 otherwise)
N        - ...then: negate (the left argument, currentState, i.e. [-cH, -cM])
 ⁹       - ...else: chain's right argument, presses
       ⁸ - chain's left argument, currentState
      +  - add
           i.e.: if presses was [1,1] then [cH+-cH,cM+-cM]=[0,0]
                 otherwise [cH+pH,cM+cM]

W;ç/%24,60
     24,60 - literal list of integers [24,60]
    %      - modulo by (vectorises)

Python 2 , 84 75 octets

lambda c,a:reduce(lambda(h,m),(d,e):(d&e)and(0,0)or((h+d)%24,(m+e)%60),a,c)

Essayez-le en ligne!

Fonction qui prend du temps en tant que tuple (heure, minute); sorties de la même manière.

Rétine , 75 octets

.*,1:1
:
\d+
$*
O`\D1*
,

1>`:

+`1{24}:|:1{60}
:
(?<=^|:)1*
$.&
\b\d\b
0$&

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

.*,1:1
:

Supprimez tout jusqu'à et y compris la dernière double pression sur un bouton, en le remplaçant par un temps vide (dans le cas où c'est la dernière pression sur un bouton).

\d+
$*

Convertissez en unaire.

O`\D1*

Triez les minutes jusqu'à la fin.

,

Ajoutez les heures ensemble.

1>`:

Ajoutez les minutes ensemble, mais en gardant les heures séparées.

+`1{24}:|:1{60}
:

Réduisez les heures et les minutes modulo 24 ou 60 selon le cas.

(?<=^|:)1*
$.&

Convertissez en décimal.

\b\d\b
0$&

Format à deux chiffres.

Python 3, 135 117 117 115 octets

^{-20 octets grâce à Jonathan Frech}

def a(m,f):
 for b,c in f:
  if b&c:m=[0,0]
  elif b:m[0]=-~m[0]*(m[0]<23)
  elif c:m[1]=-~m[1]*(m[1]<59)
 return m

Essayez-le en ligne!

Prend le temps sous forme de liste dans le formulaire [hour, minute].

Haskell , 58 octets

foldl(#)
_#(1,1)=(0,0)
(h,m)#(x,y)=(mod(h+x)24,mod(m+y)60)

Essayez-le en ligne! Exemple d' utilisation: foldl(#) (23,58) [(0,1),(1,0),(0,0),(0,1),(0,1)].

JavaScript (ES6), 55 octets

t=>a=>a.map(x=>x>2?t=[0,0]:t[x-1]++)&&[t[0]%60,t[1]%24]

Prend les entrées dans la syntaxe de curry, avec l'heure de début sous forme de tableau [min, hour]et les étapes sous forme de tableau quaternaire. Le temps de sortie est au même format que le temps d'entrée.

Cas de test

let f=
t=>a=>a.map(x=>x>2?t=[0,0]:t[x-1]++)&&[t[0]%60,t[1]%24]

;[[[49, 06], [1]], [[23, 12], [2]], [[23, 02], [2, 1]], [[40, 21], [1, 1, 1, 1]], [[10, 13], [1, 1, 1, 1, 2, 3, 1, 1]], [[33, 21], [2, 1, 2, 1]], [[21, 14], [1, 1, 1]], [[39, 02], [1, 0]], [[07, 16], [1, 1, 1, 1, 2, 2, 1, 1, 2, 1, 1, 1]], [[55, 17], [1, 2, 1]], [[55, 15], [2, 2, 2, 1, 1, 1, 2, 2, 1, 2, 2, 1, 2]], [[11, 22], [1, 2, 1, 1, 1, 1, 1, 2, 1, 1]], [[58, 03], [2, 0, 0, 1, 1, 2, 2, 1, 1, 2, 1]], [[02, 13], [1, 2, 1, 2, 1, 1, 2]], [[37, 04], [2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2]], [[01, 00], [1, 2, 2, 1, 1, 1, 2, 1, 1, 1]], [[58, 02], [2, 2, 1]], [[43, 01], [1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1]], [[54, 07], [2, 1, 2, 2, 3]], [[33, 09], [1, 1, 1, 2, 1, 1]], [[01, 09], [1, 1]], [[04, 19], [1, 2, 1, 2]], [[17, 11], [1, 2, 1, 1, 2, 1, 1, 3, 1, 1]], [[32, 19], [1, 2, 1, 2, 2, 2]], [[31, 17], [1, 1, 1, 2, 1, 2, 1, 0, 3, 1]], [[46, 06], [1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, 2, 1, 1, 1, 2, 2, 1, 1, 1, 2, 1, 2, 1, 1, 2, 1, 1, 1, 2, 2, 1, 2, 1, 1, 1, 1, 1]]]
.forEach(([time,steps])=>{
  let res = f([...time])(steps)
  console.log(JSON.stringify(time)+" -> "+JSON.stringify(res))
})

.as-console-wrapper{max-height:100%!important}

Perl 6 , 40 octets

{.reduce({(@^a Z+@^b)X*!@b.min})Z%24,60}

Essayez-le en ligne!

Prend une liste contenant l'heure de début suivie des pressions sur les touches. Renvoie l'heure de fin. Les heures et les boutons sont des (hour, minute)paires. 24 heures.

Perl 5 , 70 octets

69 octets de code + 1 pour le -ndrapeau

s/.*d/0:0/;/(.*):(\d+)/;printf"%02d:%02d",($1+y/c//)%24,($2+y/b//)%60

Essayez-le en ligne!

Format d'entrée

hh:mm,abcdabcdabcdaddccbbaa

où:

hh=start hour
mm=start minute
 a = (0, 0) = no buttons pressed
 b = (0, 1) = minute button pressed
 c = (1, 0) = hour button pressed
 d = (1, 1) = both buttons pressed

Les espaces ou autres séparateurs entre les presses sont insignifiants.

Explication

s/.*d/0:0/;    # If both buttons were ever pressed, previous presses
               # don't matter.  Get rid of them and set start time to midnight.
/(.*):(\d+)/;  # Extract start hour and minute
printf"%02d:%02d",            # Output numbers with leading 0
($1+y/c//)%24,                # Take starting hour, add number of presses, remainder 24
($2+y/b//)%60                 # Take starting minute, add number of presses, remainder 24

Swift , 106 96 octets

-10, grâce à Xcoder

func x(m:(Int,Int),n:[(Int,Int)]){let i=n.reduce(m){($0.0+$1.0,$0.1+$1.1)};print(i.0%24,i.1%60)}

Essayez-le sur ideone!

La fonction prendra la valeur initiale et le tableau de tuples et renvoie l'heure finale.

Logo Terrapin, 304 octets

Pas optimisé; beaucoup d'espaces.

MAKE "M :B MAKE "H :A LABEL "L IF EMPTY? :I OP LIST :H :M MAKE "C FIRST :I IF AND ((ITEM 2 :C)=1) ((ITEM 1 :C) = 0) MAKE "M :M+1 IF :M=60 MAKE "M 0 IF AND ((ITEM 1 :C) = 1) ((ITEM 2 :C)=1 MAKE "M 0 MAKE "H 0 IF AND ((ITEM 1 :C)-1) ((ITEM 2 :C) = 0) MAKE "H :H + 1 IF :H = 23 MAKE "H 0 MAKE "I BF :I GO "L

Prend une liste comme première entrée et l'heure + minute de départ (entrées séparées) comme deuxième et troisième, respectivement.

Je ne peux pas copier + coller à partir du logo Terrapin car c'est une version d'essai, c'est donc :(

R , 61 octets

function(I,B){for(b in B)I=I+"if"(sum(b)>1,-I,b)
I%%c(24,60)}

Prend Icomme vecteur longueur 2 c(H,M)et Bque la liste des vecteurs de longueur-2 pour les boutons, c(H,M). Fait passer dans B, la mise Ià c(0,0)si la somme est 2. Ensuite, il modifie à la fin. Il y a aussi une fonction dans l'en-tête pour traduire les pressions de bouton dans le bon format R si vous souhaitez les tester toutes; il prend le tableau [(H,M),...]comme une chaîne.

Essayez-le en ligne!

C # (.NET Core) , 93 octets

(n,l)=>{for(int i=0,x;i<n.Length;){x=n[i++];if(x>1)l[0]=l[1]=0;else{l[x]=++l[x]%(24+36*x);}}}

Essayez-le en ligne!

Prend l'entrée comme en trinaire, avec 0 == (1,0), 1 == (0,1), 2 == (1,1) et l'heure dans un tableau avec l'index 0 étant les heures et 1 étant les minutes. Modifie le tableau temporel en place.

Pyth, 22 octets

%Vu?.AH,00+VGHEQ,24 60

Essayez-le ici.

Mathematica, 54 octets

Switch[#2,a={0,0},#,a+1,a,_,Mod[+##,{24,60}]]&~Fold~#&

Fonction anonyme. Prend une liste de 2 tuples en entrée et retourne un 2-tuple en sortie.

Scala , 116 octets

Je prends donc juste l'heure de début comme deux premiers paramètres de mon func ( het m), et je prends la séquence d'entrée comme un tableau [Tuple2].

var x=h
var y=m
for(u<-a)u match{case (0,1)=>y=(y+1)%60
case (1,0)=>x=(x+1)%24
case (1,1)=>{x=0;y=0}
case _=>}
(x,y)

Je me demande ... devrais-je compter la déclaration func ( def time(h:Int,m:Int,a:Array[Tuple2[Int,Int]]):Tuple2[Int,Int]={plus la fin }) en nombre d'octets?

Essayez-le en ligne!