Ich habe einen blöden alten Wecker mit zwei Knöpfen: hourund minute. Die hourTaste erhöht die Stunde eines eingestellten Alarms und minutedie Minutenzeit eines eingestellten Alarms. Einige clevere Designer erkannten jedoch, dass das gleichzeitige Drücken beider Tasten eine Bedeutung haben sollte, und entschieden, dass durch Drücken von hourund minutegleichzeitig der Alarm auf 12:00 am/ gesetzt wird 0:00. Ihre Aufgabe ist es, dieses Verhalten zu simulieren.

Aufgabe

Bestimmen Sie bei gegebener Startzeit und einer Folge von Schaltflächenzuständen die Endzeit.

Erhöhen Sie ab der Startzeit die Stunde für jedes Vorkommen von (1,0), erhöhen Sie die Minute für jedes Vorkommen von (0,1)und stellen Sie die Zeit auf 0:00für jedes Vorkommen von ein (1,1). Die Zustände (0,0)sollten ignoriert werden, da sie keiner gedrückten Taste entsprechen.

Wenn die Minuten und Stunden addiert werden und die Minuten / Stunden das Maximum überschreiten, stellen Sie dies auf 0ein. Wenn Sie also einen Minutenwert von 59erhöhen, stellen Sie den Minutenwert auf 0und einen Stundenwert von 23erhöhen, stellen Sie den Stundenwert auf ein 0. Das Erhöhen der Minuten- / Stundenwerte über ihre Grenzen hinaus hat keinen Einfluss auf den anderen Wert, z. B. das Erhöhen der 10:59Minutenerträge 10:00, nicht 11:00.

Beispiel

In Anbetracht der Eingabezeit 13:58und Schritte [(0,1),(0,1),(0,1),(0,0),(1,1),(1,0)],

1. (0,1). Dies entspricht minutedem Drücken. Die Zeit ist jetzt 13:59.
2. (0,1). Dies entspricht minutedem Drücken. Die Zeit ist jetzt 13:00.
3. (0,1). Dies entspricht minutedem Drücken. Die Zeit ist jetzt 13:01.
4. (0,0). Dies entspricht keiner gedrückten Taste. Die Zeit ist jetzt unberührt13:01
5. (1,1). Dies entspricht dem Drücken beider Tasten. Die Zeit ist jetzt 0:00.
6. (1,0)Dies entspricht hourdem Drücken. Die Zeit ist jetzt 1:00.

Da wir mit enden 1:00, ist es die Ausgabe.

I / O

Die Eingabe besteht aus einer Zeit und einer Folge von Tastenzuständen. Die Ausgabe erfolgt einmalig.

Die Eingabezeit und die Ausgabezeit können sein

• ein 2-Tupel (hour, minute)oder (minute, hour)in- 24Stunden-Zeit wie (13, 30)( hourreicht von 0bis 23und minutereicht von 0bis 59)
• Wie vorher, jedoch in 12Stunden und mit einem Booleschen Wert am/ pmSchalter ( hourBereich von 0bis 11oder 12und 1bis 11mit minutevon 0bis 59).
• eine Anzahl von Minuten seit 0:00wie 810 (von 0 bis einschließlich 1439)
• jedes andere Format, das die gleichen Informationen codiert

Die Reihenfolge der Schaltflächenzustände ist eine Darstellung einer Liste von Booleschen 2-Tupeln, zum Beispiel:

• eine Liste von Tupeln: [(0,1),(1,0),(0,0),(1,1)]
• eine durch Leerzeichen getrennte Zeichenfolge: "01 10 00 11"
• ein Faden: "01100011"
• im Quartär: [1,2,0,3]
• in eine ganze Zahl umgewandelt: 99
• jedes andere Format, das die gleichen Informationen codiert

Testfälle

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

Gelee , 13 Bytes

_`+Ạ}?/%24,60

Probieren Sie es online!

C 89 87 Bytes

Vielen Dank an Jonathan Frech für das Speichern von zwei 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);}

Probieren Sie es online!

Jelly ,  21  (17?) 19 Bytes

^{17 Bytes? - Wenn das Eingabeformat: [[initHour, initMinute], [a1, b1], [a2, b2], ...]akzeptabel ist, haben wir einen monadischen Link und entfernen ihn möglicherweise W;vom Anfang der zweiten Zeile.}

Hinweis: Dies ist jetzt eine Annäherung an die Antwort von Erik the Outgolfers Jelly , sodass ich mich nicht mehr ums Golfen kümmern werde (ich hatte es noch nicht gesehen) ...

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

Ein dyadischer Link mit einer Liste der Anfangszeit als Ganzzahl [hour, minute](24 Stunden) auf der linken Seite und einer Liste der Schaltflächen [[hourPressed, minPressed], ...]auf der rechten Seite,
die wiederum eine Liste der Endergebniszeit als Ganzzahl [hour, minute](24 Stunden) zurückgibt .

Probieren Sie es online! oder sehen Sie sich die Testsuite an

Wie?

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)

Probieren Sie es online!

Funktion, die Zeit als Tupel benötigt (Stunde, Minute); Ausgänge auf die gleiche Weise.

Netzhaut , 75 Bytes

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

1>`:

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

Probieren Sie es online! Link enthält Testfälle. Erläuterung:

.*,1:1
:

Löschen Sie alles bis einschließlich des letzten doppelten Tastendrucks und ersetzen Sie es durch eine leere Zeit (falls dies der letzte Tastendruck ist).

\d+
$*

In Unary konvertieren.

O`\D1*

Sortieren Sie die Minuten bis zum Ende.

,

Addiere die Stunden zusammen.

1>`:

Fügen Sie die Minuten zusammen, aber halten Sie die Stunden getrennt.

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

Reduzieren Sie die Stunden- und Minutenmodule 24 oder 60 entsprechend.

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

In Dezimalzahl konvertieren.

\b\d\b
0$&

Format auf zwei Ziffern.

Python 3, 135 117 115 Bytes

^{-20 Bytes dank 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

Probieren Sie es online!

Nimmt die Zeit als Liste im Formular [hour, minute].

Haskell , 58 Bytes

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

Probieren Sie es online! Beispiel Nutzung: 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]

Nimmt Eingaben in Curry-Syntax vor, wobei die Startzeit in der Array-Form [min, hour]und die Schritte als quartäres Array angegeben werden. Die Ausgabezeit hat dasselbe Format wie die Eingabezeit.

Testfälle

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}

Probieren Sie es online!

Nimmt eine Liste mit der Startzeit gefolgt von den Tastendrücken auf. Gibt die Endzeit zurück. Zeiten und Schaltflächen sind (hour, minute)Paare. 24 Stunden Zeit.

Perl 5 , 70 Bytes

69 Byte Code + 1 für -nFlag

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

Probieren Sie es online!

Eingabeformat

hh:mm,abcdabcdabcdaddccbbaa

woher:

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

Zwischenräume oder andere Abstandshalter zwischen den Pressen sind unerheblich.

Erläuterung

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, danke an 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)}

Probiere es auf ideone aus!

Die Funktion nimmt den Anfangswert und ein Array von Tupeln an und gibt die letzte Zeit zurück.

Sumpfschildkröten-Logo, 304 Bytes

Nicht optimiert; viele Räume.

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

Nimmt eine Liste als erste Eingabe und die Startstunde + Minute (separate Eingaben) als zweite bzw. dritte.

Ich kann Terrapin Logo nicht kopieren und einfügen, da es sich um eine Testversion handelt.

R , 61 Bytes

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

Wird Ials Längen-2-Vektor c(H,M)und Bals Liste von Längen-2-Vektoren für die Schaltflächen verwendet c(H,M). Durchläuft Bund setzt Iauf, c(0,0)wenn die Summe ist 2. Dann geht es am Ende runter. Es gibt auch eine Funktion in der Kopfzeile, mit der Sie die Tastendrücke in das richtige R-Format übersetzen können, wenn Sie alle testen möchten. Das Array wird [(H,M),...]als Zeichenfolge verwendet.

Probieren Sie es 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);}}}

Probieren Sie es online!

Nimmt Eingaben wie in Trinary vor, wobei 0 == (1,0), 1 == (0,1), 2 == (1,1) und die Zeit in einem Array mit Index 0 Stunden und 1 Minuten sind. Ändert das vorhandene Zeitarray.

Pyth, 22 Bytes

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

Probieren Sie es hier aus.

Mathematica, 54 Bytes

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

Anonyme Funktion. Nimmt eine Liste von 2-Tupeln als Eingabe und gibt ein 2-Tupel als Ausgabe zurück.

Scala , 116 Bytes

Ich nehme also einfach die Startzeit als zwei erste Parameter meiner Funk ( hund m) und nehme die Eingabesequenz als Array [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)

Ich frage mich, ob ich die Funkdeklaration ( def time(h:Int,m:Int,a:Array[Tuple2[Int,Int]]):Tuple2[Int,Int]={plus die Endung }) in Byte zählen soll.

Probieren Sie es online!