Tengo un viejo y estúpido despertador con dos botones: houry minute. El hourbotón incrementa la hora de una alarma configurada e minuteincrementa los minutos de una alarma configurada. Sin embargo, algunos diseñadores inteligentes se dieron cuenta de que presionar ambos botones al mismo tiempo debería tener un significado, y decidieron que presionar houryminute simultáneamente provocaría que la alarma se configurara en 12:00 am/0:00 . Su tarea es simular este comportamiento.

Tarea

Dada una hora de inicio y una secuencia de estados de botón, calcule la hora de finalización.

Comenzando desde la hora de inicio, incremente la hora para cada ocurrencia de (1,0), incremente el minuto para cada ocurrencia de (0,1)y configure el tiempo en 0:00para cada ocurrencia de (1,1). Los Estados(0,0) deben ignorarse porque no corresponden a ninguno de los botones que se presionan.

Al agregar minutos y horas, si el minuto / hora supera el máximo, configúrelo en 0, es decir, al incrementar el valor de un minuto 59debería establecer el valor de minuto en 0y al incrementar el valor de 23la hora debería establecer el valor de la hora en 0. Incrementar valores minutos / hora por encima de sus límites no afectan el otro valor, por ejemplo incrementando el minuto de 10:59rendimientos 10:00, no 11:00.

Ejemplo

Dado el tiempo de entrada 13:58y los pasos [(0,1),(0,1),(0,1),(0,0),(1,1),(1,0)],

1. (0,1). Esto corresponde a minuteser presionado. El momento es ahora 13:59.
2. (0,1). Esto corresponde a minuteser presionado. El momento es ahora 13:00.
3. (0,1). Esto corresponde a minuteser presionado. El momento es ahora 13:01.
4. (0,0). Esto corresponde a que no se presione ningún botón. El tiempo, no afectado, es ahora13:01
5. (1,1). Esto corresponde a que se presionen ambos botones. El momento es ahora 0:00.
6. (1,0)Esto corresponde a hourser presionado. El momento es ahora 1:00.

Como terminamos con 1:00, es la salida.

I / O

La entrada consistirá en un tiempo y una secuencia de estados de botón. La salida es una sola vez.

El tiempo de entrada y el tiempo de salida pueden ser

• un tiempo de 2 tuplas de (hour, minute)o (minute, hour)dentro de una 24hora como (13, 30)( hourrangos de 0a 23y minuterangos de 0a 59)
• igual que el anterior pero en 12-Hora tiempo y un booleano am/ pminterruptor ( hourrangos de 0a 11o 12y 1a 11con minutede 0a59 ).
• una cantidad de minutos desde 0:00 810 (de 0 a 1439, inclusive)
• cualquier otro formato que codifique la misma información

La secuencia de estados de botón es una representación de una lista de 2 tuplas booleanas, por ejemplo:

• una lista de tuplas: [(0,1),(1,0),(0,0),(1,1)]
• una cadena delimitada por espacios: "01 10 00 11"
• una cuerda: "01100011"
• en cuaternario: [1,2,0,3]
• convertido a un entero: 99
• cualquier otro formato que codifique la misma información

Casos de prueba

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

Jalea , 13 bytes

_`+Ạ}?/%24,60

Pruébalo en línea!

C, 89 87 bytes

¡Gracias a @Jonathan Frech por guardar dos bytes!

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);}

Pruébalo en línea!

Jalea ,  21  (17?) 19 bytes

^{17 bytes? - Si el formato de entrada: [[initHour, initMinute], [a1, b1], [a2, b2], ...]es aceptable, tendríamos un enlace monádico y podríamos eliminarlo W;desde el comienzo de la segunda línea.}

Nota: Esto ahora está convergiendo hacia la respuesta de Erik the Outgolfers Jelly , así que no me molestaré más en jugar golf (no lo había visto) ...

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

Un enlace diádico que toma una lista de la hora inicial como enteros [hour, minute](24 horas) a la izquierda y una lista de estados de botones [[hourPressed, minPressed], ...]a la derecha
que devuelve una lista del tiempo del resultado final como enteros, nuevamente [hour, minute](24 horas).

Pruébalo en línea! o ver el pruebas

¿Cómo?

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 bytes

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

Pruébalo en línea!

Función que lleva tiempo como una tupla (hora, minuto); salidas de la misma manera.

Retina , 75 bytes

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

1>`:

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

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

.*,1:1
:

Elimine todo hasta la última pulsación del botón doble, reemplazándola por un tiempo vacío (en caso de que sea la última pulsación del botón).

\d+
$*

Convierte a unario.

O`\D1*

Ordena los minutos hasta el final.

,

Suma las horas juntas.

1>`:

Agregue los minutos juntos, pero manteniendo las horas separadas.

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

Reduzca las horas y minutos módulo 24 o 60 según corresponda.

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

Convierte a decimal.

\b\d\b
0$&

Formatear a dos dígitos.

Python 3, 135 117 115 bytes

^{-20 bytes gracias a 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

Pruébalo en línea!

Toma el tiempo como una lista en el formulario [hour, minute].

Haskell , 58 bytes

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

Pruébalo en línea! Ejemplo de uso: foldl(#) (23,58) [(0,1),(1,0),(0,0),(0,1),(0,1)].

JavaScript (ES6), 55 bytes

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

Toma la entrada en la sintaxis de curry, con el tiempo de inicio en la forma de matriz [min, hour]y los pasos como una matriz cuaternaria. El tiempo de salida está en el mismo formato que el tiempo de entrada.

Casos de prueba

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 bytes

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

Pruébalo en línea!

Toma una lista que contiene la hora de inicio seguida de presionar el botón. Devuelve la hora de finalización. Los tiempos y los botones son (hour, minute)pares. Tiempo de 24 horas.

Perl 5 , 70 bytes

69 bytes de código + 1 para -nbandera

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

Pruébalo en línea!

Formato de entrada

hh:mm,abcdabcdabcdaddccbbaa

dónde:

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

Los espacios u otros separadores entre las prensas son insignificantes.

Explicación

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 bytes

-10, gracias a 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)}

Pruébalo en ideone!

La función tomará el valor inicial y la matriz de tuplas y devolverá el tiempo final.

Logotipo de Terrapin, 304 bytes

No optimizado muchos espacios

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

Toma una lista como su primera entrada y la hora de inicio + minuto (entradas separadas) como segunda y tercera, respectivamente.

No puedo copiar + pegar desde el logotipo de Terrapin ya que es una versión de prueba, así que eso es :(

R , 61 bytes

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

Toma Icomo un vector de longitud-2 c(H,M)y Bcomo una lista de longitud-2 vectores para los botones, c(H,M). Itera B, el establecimiento Ide c(0,0)si la suma es 2. Luego se modifica al final. También hay una función en el encabezado para traducir las pulsaciones de botón al formato R correcto si desea probarlas todas; toma la matriz [(H,M),...]como una cadena.

Pruébalo en línea!

C # (.NET Core) , 93 bytes

(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);}}}

Pruébalo en línea!

Toma la entrada como en trinario, con 0 == (1,0), 1 == (0,1), 2 == (1,1), y el tiempo en una matriz con el índice 0 son horas y 1 son minutos. Modifica la matriz de tiempo en su lugar.

Pyth, 22 bytes

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

Pruébalo aquí.

Mathematica, 54 bytes

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

Función anónima. Toma una lista de 2 tuplas como entrada y devuelve una 2 tuplas como salida.

Scala , 116 bytes

Así que tomo el tiempo de inicio como dos primeros parámetros de mi func ( hy m), y tomo la secuencia de entrada como una matriz [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)

Me pregunto ... ¿debería contar la declaración de func ( def time(h:Int,m:Int,a:Array[Tuple2[Int,Int]]):Tuple2[Int,Int]={más el final }) en el recuento de bytes?

Pruébalo en línea!