Ho una stupida vecchia sveglia con due pulsanti: houre minute. Il hourpulsante aumenta l'ora di una sveglia impostata e minuteaumenta la durata dei minuti di una sveglia impostata. Tuttavia, alcuni designer intelligenti si sono resi conto che la pressione contemporanea di entrambi i pulsanti avrebbe dovuto avere un significato e hanno deciso che premendo houre minutecontemporaneamente si sarebbe impostato l'allarme su 12:00 am/ 0:00. Il tuo compito è simulare questo comportamento.

Compito

Data l'ora di inizio e una sequenza di stati dei pulsanti, capire l'ora di fine.

A partire dall'ora di inizio, incrementa l'ora per ogni occorrenza di (1,0), incrementa il minuto per ogni occorrenza di (0,1)e imposta l'ora su 0:00per ogni occorrenza di (1,1). Gli stati (0,0)devono essere ignorati perché non corrispondono a nessuno dei due pulsanti.

Quando si aggiunge a minuti e ore, se il minuto / ora supera il massimo, impostarlo su 0, ovvero se si aumenta un valore di minuto si 59dovrebbe impostare il valore di minuto su 0e incrementando un valore di ora si 23dovrebbe impostare il valore di ora su 0. L'incremento dei valori minuto / ora al di sopra dei loro limiti non influisce sull'altro valore, ad esempio incrementando il minuto dei 10:59rendimenti 10:00, no 11:00.

Esempio

Dati i tempi di input 13:58e i passaggi [(0,1),(0,1),(0,1),(0,0),(1,1),(1,0)],

1. (0,1). Questo corrisponde ad minuteessere premuto. I tempi sono adesso 13:59.
2. (0,1). Questo corrisponde ad minuteessere premuto. I tempi sono adesso 13:00.
3. (0,1). Questo corrisponde ad minuteessere premuto. I tempi sono adesso 13:01.
4. (0,0). Ciò corrisponde a nessuno dei due pulsanti premuti. Il tempo, intatto, è adesso13:01
5. (1,1). Ciò corrisponde alla pressione di entrambi i pulsanti. I tempi sono adesso 0:00.
6. (1,0)Questo corrisponde ad houressere premuto. I tempi sono adesso 1:00.

Da quando finiamo con 1:00, è l'output.

I / O

L'input consisterà in un tempo e una sequenza di stati dei pulsanti. L'output è una sola volta.

Il tempo di ingresso e il tempo di uscita possono essere

• una tupla di 2 (hour, minute)o (minute, hour)in 24-ora come (13, 30)( hourintervalli da 0a 23e minuteintervalli da 0a 59)
• uguale al tempo precedente ma in 12-ora e un interruttore booleano am/ pm( hourvaria da 0a 11o 12e 1a 11con minuteda 0a a59 ).
• un certo numero di minuti da allora 0:00 da 810 (da 0 a 1439, incluso)
• qualsiasi altro formato che codifichi le stesse informazioni

La sequenza degli stati dei pulsanti è una rappresentazione di un elenco di 2 tuple booleane, ad esempio:

• un elenco di tuple: [(0,1),(1,0),(0,0),(1,1)]
• una stringa delimitata da spazi: "01 10 00 11"
• una stringa: "01100011"
• in quaternario: [1,2,0,3]
• convertito in un numero intero: 99
• qualsiasi altro formato che codifichi le stesse informazioni

Casi 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

Gelatina , 13 byte

_`+Ạ}?/%24,60

Provalo online!

C, 89 87 byte

Grazie a @Jonathan Frech per aver salvato due byte!

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

Provalo online!

Gelatina ,  21  (17?) 19 byte

^{17 byte? - Se il formato di input: [[initHour, initMinute], [a1, b1], [a2, b2], ...]è accettabile, avremmo un collegamento monadico e potremmo rimuovereW; dall'inizio della seconda riga.}

Nota: questo sta ora convergendo verso la risposta di Erik the Outgolfers Jelly , quindi non mi preoccuperò più del golf (non l'avevo visto) ...

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

Un collegamento diadico che prende un elenco dell'ora iniziale come numeri interi [hour, minute](24 ore) a sinistra e un elenco di stati dei pulsanti [[hourPressed, minPressed], ...]sulla destra
che restituisce di nuovo un elenco dell'ora del risultato finale come numeri interi [hour, minute](24 ore).

Provalo online! o vedi la suite di test

Come?

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 byte

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

Provalo online!

Funzione che richiede tempo come tupla (ora, minuti); produce allo stesso modo.

Retina , 75 byte

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

1>`:

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

Provalo online! Il link include casi di test. Spiegazione:

.*,1:1
:

Elimina tutto fino all'ultima pressione del doppio pulsante inclusa, sostituendola con un tempo vuoto (nel caso in cui sia l'ultima pressione del pulsante).

\d+
$*

Converti in unario.

O`\D1*

Ordina i minuti fino alla fine.

,

Aggiungi le ore insieme.

1>`:

Aggiungi i minuti insieme, ma mantenendo le ore separate.

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

Ridurre le ore e i minuti modulo 24 o 60 come appropriato.

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

Converti in decimale.

\b\d\b
0$&

Formatta su due cifre.

Python 3, 135 117 115 byte

^{-20 byte grazie 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

Provalo online!

Prende il tempo come un elenco nel modulo [hour, minute].

Haskell , 58 byte

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

Provalo online! Esempio di utilizzo: foldl(#) (23,58) [(0,1),(1,0),(0,0),(0,1),(0,1)].

JavaScript (ES6), 55 byte

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

Accetta input nella sintassi del curry, con l'ora di inizio nella forma dell'array [min, hour]e i passaggi come matrice quaternaria. Il tempo di uscita è nello stesso formato del tempo di ingresso.

Casi 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 byte

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

Provalo online!

Prende un elenco contenente l'ora di inizio seguita dalla pressione del pulsante. Restituisce l'ora di fine. I tempi e i pulsanti sono (hour, minute)coppie. 24 ore.

Perl 5 , 70 byte

69 byte di codice + 1 per -nflag

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

Provalo online!

Formato di input

hh:mm,abcdabcdabcdaddccbbaa

dove:

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

Gli spazi o altri separatori tra le presse sono insignificanti.

Spiegazione

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

Rapido , 106 96 byte

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

Provalo su ideone!

La funzione prenderà il valore iniziale e l'array di tuple e restituirà il tempo finale.

Logo Terrapin, 304 byte

Non ottimizzato; molti spazi.

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

Prende un elenco come primo input e ora + minuto iniziale (input separati) rispettivamente come secondo e terzo.

Non riesco a copiare + incollare dal logo Terrapin in quanto è una versione di prova, quindi è :(

R , 61 byte

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

Prende Icome vettore lunghezza-2 c(H,M)e Bcome un elenco di lunghezza-2 vettori per i pulsanti, c(H,M). Scorre B, impostando Isuc(0,0) se la somma è 2. Quindi si riduce alla fine. C'è anche una funzione nell'intestazione per tradurre le pressioni dei pulsanti nel giusto formato R se desideri testarle tutte; prende l'array [(H,M),...]come una stringa.

Provalo online!

C # (.NET Core) , 93 byte

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

Provalo online!

Accetta input come in trinary, con 0 == (1,0), 1 == (0,1), 2 == (1,1) e il tempo in un array con l'indice 0 pari a ore e 1 a minuti. Modifica l'array di tempo in atto.

Pyth, 22 byte

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

Provalo qui.

Mathematica, 54 byte

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

Funzione anonima. Prende un elenco di 2 tuple come input e restituisce una 2 tupla come output.

Scala , 116 byte

Quindi prendo l'ora di inizio come due primi parametri del mio func ( he m) e prendo la sequenza di input come una matrice [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)

Mi chiedo ... dovrei contare la dichiarazione di funzione ( def time(h:Int,m:Int,a:Array[Tuple2[Int,Int]]):Tuple2[Int,Int]={più la fine }) nel conteggio dei byte?

Provalo online!