Eu tenho um velho despertador estúpido com dois botões: houre minute. O hourbotão incrementa a hora de um alarme definido e minuteaumenta a hora em minutos de um alarme definido. No entanto, alguns designers inteligentes perceberam que pressionar os dois botões ao mesmo tempo deveria ter um significado e decidiram que pressionar houre minutesimultaneamente faria com que o alarme fosse definido como 12:00 am/ 0:00. Sua tarefa é simular esse comportamento.

Tarefa

Dada a hora de início e uma sequência de estados dos botões, calcule a hora de término.

A partir da hora de início, aumente a hora para cada ocorrência de (1,0), aumente o minuto para cada ocorrência de (0,1)e defina a hora 0:00para cada ocorrência de (1,1). Os estados (0,0)devem ser ignorados porque correspondem a nenhum botão sendo pressionado.

Ao adicionar minutos e horas, se o minuto / hora ultrapassar o máximo, defina-o como 0, isto é, incrementar um valor minuto de 59deve definir o valor minuto 0e incrementar um valor de hora 23deve definir o valor da hora 0. Incrementar valores de minuto / hora acima de seus limites não afeta o outro valor, por exemplo, incrementar o minuto de 10:59rendimentos 10:00, não 11:00.

Exemplo

Dado o tempo de entrada 13:58e as etapas [(0,1),(0,1),(0,1),(0,0),(1,1),(1,0)],

1. (0,1). Isso corresponde a minuteser pressionado. A hora é agora 13:59.
2. (0,1). Isso corresponde a minuteser pressionado. A hora é agora 13:00.
3. (0,1). Isso corresponde a minuteser pressionado. A hora é agora 13:01.
4. (0,0). Isso corresponde a nenhum botão sendo pressionado. A hora, não afetada, é agora13:01
5. (1,1). Isso corresponde aos dois botões sendo pressionados. A hora é agora 0:00.
6. (1,0)Isso corresponde a hourser pressionado. A hora é agora 1:00.

Desde que terminamos 1:00, é a saída.

I / O

A entrada consistirá em um tempo e uma sequência de estados dos botões. A saída é uma única vez.

O tempo de entrada e o tempo de saída podem ser

• uma tupla de duas horas (hour, minute)ou (minute, hour)em um 24horário, como (13, 30)( hourvaria de 0a 23e minutevaria de 0a 59)
• igual ao tempo anterior, mas em uma 12hora, e um interruptor booleano am/ pm( hourvaria de 0para 11ou para 12e com de para ).111minute059
• alguns minutos desde 0:00810 (de 0 a 1439, inclusive)
• qualquer outro formato que codifique a mesma informação

A sequência dos estados dos botões é uma representação de uma lista de 2 tuplas booleanas, por exemplo:

• uma lista de tuplas: [(0,1),(1,0),(0,0),(1,1)]
• uma sequência delimitada por espaço: "01 10 00 11"
• uma linha: "01100011"
• em Quaternário: [1,2,0,3]
• convertido em um número inteiro: 99
• qualquer outro formato que codifique a mesma informação

Casos de teste

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

Gelatina , 13 bytes

_`+Ạ}?/%24,60

Experimente online!

C, 89 87 bytes

Agradecemos a Jonathan Frech por salvar dois 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);}

Experimente online!

Gelatina ,  21  (17?) 19 bytes

^{17 bytes? - Se o formato de entrada: [[initHour, initMinute], [a1, b1], [a2, b2], ...]for aceitável, teríamos um link monádico e poderemos removerW; do início da segunda linha.}

Nota: Isso agora está convergindo para a resposta da Erik the Outgolfers Jelly , por isso não vou me preocupar mais em jogar golfe (eu não a tinha visto) ...

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

Um link diádico que obtém uma lista da hora inicial como números inteiros [hour, minute](24 horas) à esquerda e uma lista de estados de botão [[hourPressed, minPressed], ...]à direita
que retorna uma lista da hora do resultado final como números inteiros, novamente [hour, minute](24 horas).

Experimente online! ou veja a suíte de testes

Quão?

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)

Experimente online!

Função que leva tempo como uma tupla (hora, minuto); saídas da mesma maneira.

Retina , 75 bytes

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

1>`:

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

Experimente online! O link inclui casos de teste. Explicação:

.*,1:1
:

Exclua tudo, inclusive o último pressionamento do botão duplo, substituindo-o por um tempo vazio (caso esse seja o último pressionamento do botão).

\d+
$*

Converta para unário.

O`\D1*

Ordene os minutos até o fim.

,

Adicione as horas juntos.

1>`:

Adicione os minutos, mas mantenha as horas separadas.

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

Reduza as horas e minutos do módulo 24 ou 60, conforme apropriado.

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

Converta para decimal.

\b\d\b
0$&

Formate para dois dígitos.

Python 3, 135 117 115 bytes

^{-20 bytes graças 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

Experimente online!

Leva o tempo como uma lista no formulário [hour, minute].

Haskell , 58 bytes

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

Experimente online! Exemplo de utilização: 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]

Recebe entrada na sintaxe de curry, com o horário de início no formato da matriz [min, hour]e as etapas como uma matriz quaternária. O tempo de saída está no mesmo formato que o tempo de entrada.

Casos de teste

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}

Experimente online!

Leva uma lista contendo a hora de início seguida pelo pressionamento do botão. Retorna o horário final. Tempos e botões são (hour, minute)pares. 24 horas.

Perl 5 , 70 bytes

69 bytes de código + 1 para -nsinalizador

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

Experimente online!

Formato de entrada

hh:mm,abcdabcdabcdaddccbbaa

Onde:

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

Espaços ou outros separadores entre as prensas são insignificantes.

Explicação

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

Rápido , 106 96 bytes

-10, graças ao 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)}

Experimente em ideone!

A função assumirá o valor inicial e a matriz de tuplas e retornará a hora final.

Logotipo da tartaruga, 304 bytes

Não otimizado; muitos espaços.

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

Leva uma lista como sua primeira entrada e a hora inicial + minuto (entradas separadas) como segunda e terceira, respectivamente.

Não consigo copiar + colar do Terrapin Logo, pois é uma versão de teste, então é isso :(

R , 61 bytes

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

Toma Icomo um vetor comprimento-2 c(H,M)e Bcomo uma lista de vetores comprimento-2 para os botões c(H,M),. Repete B, definindo Icomo c(0,0)se a soma é 2. Então mods no final. Há também uma função no cabeçalho para traduzir o pressionamento de botão no formato R certo, se você quiser testá-los todos; leva a matriz[(H,M),...] como uma string.

Experimente online!

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

Experimente online!

Recebe entrada como em trinário, com 0 == (1,0), 1 == (0,1), 2 == (1,1) e o tempo em uma matriz com o índice 0 sendo horas e 1 sendo minutos. Modifica o intervalo de tempo no local.

Pitão, 22 bytes

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

Experimente aqui.

Mathematica, 54 bytes

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

Função anônima. Toma uma lista de 2 tuplas como entrada e retorna uma 2 tuplas como saída.

Scala , 116 bytes

Então, apenas tomo a hora de início como dois primeiros parâmetros da minha func ( he m) e tomo a sequência de entrada como uma 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)

Gostaria de saber ... devo contar a declaração de funções ( def time(h:Int,m:Int,a:Array[Tuple2[Int,Int]]):Tuple2[Int,Int]={mais o final} ) na contagem de bytes?

Experimente online!