Das Programm

Sie sind zwei Strings, da A und B . A ist die aktuelle Position, an der sich Ihr Timer befindet, und B ist die Position, an der Ihr Timer anhält. Beide Zeichenfolgen haben das Format m: ss . Sie müssen ein Programm schreiben, das die verbleibende Zeit festlegt, die auch als m: ss oder mm: ss formatiert werden soll .

Beispiel

0:00 0:01 -> 0:01
0:55 1:00 -> 0:05
1:45 3:15 -> 1:30

Excel, 6 Bytes

=B1-A1

Angenommen, A ist in der Zelle A1und B ist in der ZelleB1

MATL , 17 7 Bytes

YOd15XO

Die Eingabe ist ein Zellenarray von Zeichenfolgen in der Form {'1:45' '3:15'}oder {'1:45', '3:15'}.

Probieren Sie es online!

Erläuterung

YO     % Input cell array of strings (implicit). Convert to serial date numbers
d      % Difference
15XO   % Convert to format 15, i.e. 'HH:MM'. Display (implicit)

Bash + Coreutils, 44 39 Bytes

tr : \ |dc -e?r60*+r-r60*-60~rn58PA~rnn

Probieren Sie es online!

Erläuterung: Verwenden von "1:45 3:15" als Testfall (letztes Beispiel). Ich zeige Zwischenschritte in Anführungszeichen.

tr : \ |         # replace colons with spaces: "1 45 3 15"
dc -e?           # start dc script, push input to LIFO stack: "15 3 45 1"
     r60*+            # turn time B to total seconds: "195 45 1"
     r-r60*-          # turn time A to total seconds and get difference: "90"
     60~r             # turn difference (time left) to minutes and seconds: "1 30"
     n58P             # pop and print minutes, print colon (ASCII code 58): "30"
     A~rnn            # print seconds. Padding with zeroes is done by dividing by
                      #10 (A), and printing the quotient and the remainder.

Beachten Sie, dass ich nicht überprüfe, ob der Minutenwert eine Auffüllung von Null benötigt, da das OP angab, dass der Maximalwert für m9 ist.

Unten ist meine ursprüngliche 44-Byte-Antwort, die den dateBefehl verwendete, um die verbleibende Gesamtzeit in Sekunden in das m:ssFormat umzuwandeln.

date -d@`tr : \ |dc -e?r60*+r-r60*-p` +%M:%S

Python 2, 90 87 83 80 Bytes

Nimmt Eingaben wie "2:45","5:01".

a,b=[60*int(s[-5:-3])+int(s[-2:])for s in input()]
print'%d:%02d'%divmod(b-a,60)

Probieren Sie es online aus

c, 86

f(a,b,c,d){scanf("%d:%d%d:%d",&a,&b,&c,&d);d+=(c-a)*60-b;printf("%d:%02d",d/60,d%60);}

Liest durch Leerzeichen getrennte Zeiten aus STDIN.

Probieren Sie es online aus .

Batch, 74 Bytes

@set t=%2-(%1)
@set/as=%t::=*60+1%,m=s/60,t=s/10%%6
@echo %m%:%t%%s:~-1%

Durch Ersetzen der :in der Zeit durch *60+1wird sie in einen Ausdruck umgewandelt, der die Anzahl der Sekunden berechnet. Batch interpretiert führende Nullen als Oktal, daher stelle ich a 1vor die Sekunden, um die Dezimalumwandlung sicherzustellen. Zum Glück fallen die beiden 1aus.

C 112 100 Bytes

Danke an @betseg für das Speichern von 11 Bytes und danke an @Johan du Toit für das Speichern von einem Byte!

i,j;f(char*a,char*b){i=atoi(b)-atoi(a);j=atoi(b+2)-atoi(a+2);j<0?i--,j+=60:0;printf("%d:%02d",i,j);}

Probieren Sie es online!

MySQL, 13 22 Bytes

select right(timediff(B,A),5)

erwartet die mal in A und B.

Bash + GNU-Dienstprogramme, 43

date -d@`date -f- +%s|dc -e??r-60/p` +%M:%S

Probieren Sie es online aus .

Erläuterung

         date -f- +%s                        # read in 2 line-delimited dates and output as number of seconds since the epoch
                     |dc -e                  # pipe to dc expression:
                           ??                # - read 2 input numbers
                             r-              # - reverse and subtract
                               60/           # - divide by 60
                                  p          # - output
        `                          `         # evaluate date|dc command
date -d@                             +%M:%S  # format seconds difference and output

Beachten Sie, dass der dcAusdruck durch 60 geteilt wird, da datedie Eingabe als H: MM anstelle von M: SS gelesen wird.

ECMAScript 6, 99 91 85 Bytes

Einzelne Zeile:

f=s=>s.split`:`.reduce((a,e,i)=>a+e*(!i?60:1),0);t=n=>~~(n/60)+":"+n%60;t(f(b)-f(a));

Leicht formatiert:

f=s=>s.split`:`.reduce((a,e,i)=>a+e*(!i?60:1),0);
t=n=>~~(n/60)+":"+n%60;
t(f(b)-f(a));

Ich habe das Gefühl, dass es einige Einsparungen geben könnte. Aber ich sehe sie derzeit nicht.

Bearbeiten - hervorragende Vorschläge in den Kommentaren.

PHP, 55 53 Bytes

<?=date('i:s',($s=strtotime)($argv[2])-$s($argv[1]));

Nimmt Eingaben von Befehlszeilenargumenten entgegen

C #, 72 Bytes

using System;a=>b=>((DateTime.Parse(b)-DateTime.Parse(a))+"").Remove(5);

Übernimmt die Eingabe als Zeichenfolge. b="3:15" a="1:45".

Erläuterung:

Da DateTime.Parse()ein Datum im hh:mm:ssFormat zurückgegeben wird, kann ich das Ergebnis mithilfe von in eine Zeichenfolge umwandeln +""und anschließend das Ende abschneiden :00.

Dies funktioniert, hh:mmda in einer Minute 60 Sekunden und in einer Stunde 60 Minuten sind.

0:01 0:00 kehrt zurück 0:01

1:00 0:55 kehrt zurück 0:05

3:15 1:45 kehrt zurück 1:30

Rebol, 5 Bytes

b - a

Vorausgesetzt, ich habe keine Regeln verpasst ..

Rebol verfügt über eine integrierte Arithmetik für eine Reihe von Literaldatentypen. Dies gilt auch für seine Nachkommen wie Red

Pyth, 47 45 44 40 Bytes

J.U-Zbm+*60hdedmmvkcd\:.z%"%d:%02d".DJ60

Nimmt die Eingabe durch Zeilenumbrüche getrennt.

Pyth hatte dafür keine nützlichen Zeiteinbauten. Ich habe ein paar ausgefallene eval () - Sachen ausprobiert, aber anscheinend kann Pyth keine Sachen mit *oder ohne führende Nullen auswerten. Das wurde viel länger als ich gehofft hatte. Einige Bytes werden für das Hinzufügen einer führenden Null zur Ausgabe aufgewendet. Zumindest bin ich kleiner als Bash. Fügt bei Aufforderung eine Erklärung hinzu.

Versuche dies!

alternative Lösung, 48 Bytes

J.U-Zbm+*60hdh_dmmvkcd\:.z
K%J60
s[/J60\:*<KT\0K

Haskell, 98 127 86 Bytes

r(m:_:s)=60*read[m]+read s
a#b|(d,m)<-divMod(r b-r a)60=show d++':':['0'|m<=9]++show m

Probieren Sie es online!

Aber ich frage mich, ob es dafür einige Bibliotheksfunktionen gibt

BEARBEITEN: Der Import wurde entfernt, außerdem wurde ein Fehler behoben, bei dem m: s statt m: ss angezeigt wurde

Auch gut formatierte Version:

convert :: String -> Integer
convert (a:_:b) = (read [a])*60+(read b)

diffTime :: String -> String -> String
diffTime s1 s2 = let (d,m) = divMod (c b-c a) 60 in show d ++ ":" ++ pad2d m

pad2d :: Int -> String
pad2d n = ['0'|n<=9]++show n

EDIT2: Aus (30?) Bytes dank Laikoni! Golf auch einige andere misc. Bytes.

T-SQL, 238 Bytes

CREATE PROCEDURE d @a time,@b time AS BEGIN DECLARE @d int DECLARE @s varchar(2) SET @d=datediff(s,@a,@b);SET @s=CAST(@d%3600/60 AS VARCHAR(3)) SELECT CAST(@d/3600 AS VARCHAR(3))+':'+(SELECT CASE WHEN LEN(@s)=1 THEN '0'+@s ELSE @s END)END

Verwendung:

EXEC d '00:55','01:00'

Als ich das PostGres-Beispiel sah, stellte ich fest, dass ich in SQL nicht viele Golfversuche gesehen hatte, und versuchte es in T-SQL. Jetzt weiß ich, warum Sie in SQL nicht viel Golf spielen sehen: D

CJam , 34 33 25 Bytes

8 Bytes gespart dank Martin Ender!

{r':/60b}2*\m60mds2Te[':\

Probieren Sie es online!

Erläuterung

{             e# Start of block
 r            e#  Read one time from input
 ':/          e#  Split on colons, gives [minutes seconds]
 60b          e#  Convert from base 60
}2*           e# Run this block 2 times
              e# At this point, we have the two times in seconds on the stack
\             e# Swap top elements
m             e# Subtract
60md          e# Divmod the result by 60, to convert back to minutes and seconds
s             e# Convert the seconds to a string
2Te[          e# Pad it to 2 characters by adding 0s to the left (T = 0)
':            e# Push a colon character
\             e# Swap top elements, bringing seconds back to the top

T-SQL, 82 Bytes

select left(cast(dateadd(minute, datediff(S,'0:00','0:01')/60,114) as time(0)), 5)

Python, 160 Bytes

Ich bin noch ein Neuling im Codieren von Golf. Wenn also jemand Vorschläge hat, würde ich mich freuen.

a, b = input()
def z(x):
    x = x.split(":")
    return int(x[0])*60+int(x[1])
a, b = z(a),z(b)
s, m = b-a,0
while s >= 60:
    s -= 60
    m += 1
print(str(m)+":"+str(s))

REXX, 79 Bytes

arg t q
say right(time(,f(q)-f(t),s),5)
f:return time(s,'00:'right(arg(1),5,0))

Pyth, 28

%"%d:%02d".Dh.+misMcd\:60Q60

Probieren Sie es aus .

Erläuterung

                   cd\:      # lambda to split c on ":"
                 sM          # map to convert string to int
               mi      60Q   # convert from base-60 list to give seconds
             .+              # delta of the two seconds values
            h                # single-item list to int
          .D              60 # divmod by 60
%"%d:%02d"                   # format output

Java 7, 164 Bytes

String c(String a,String b){long s=x(b,1)-x(a,1)+(x(b,0)-x(a,0))*60,m=s%60;return(s/60)+":"+(m>9?m:"0"+m);}long x(String s,int i){return new Long(s.split(":")[i]);}

Erläuterung:

String c(String a, String b){       // Method with two String parameters and String return-type
  long s = x(b,1) - x(a,1)          //  Get difference in seconds from input times
           + (x(b,0) - x(a,0)*60,   //   plus the difference in minutes times 60 to get the seconds
    m = s%60;                       //  Temp variable of seconds after we've subtracted the minutes (used multiple times)
  return (s/60)                     //  Return minutes
    +":"                            //   plus ":"
    +(m>9?m:"0"+m);                 //   plus seconds (with a leading 0 if necessary)
}                                   // End of method

long x(String s,int i){             // Separate ethod with String and Integer parameters and long return-type
  return new Long(s.split(":")[i];  //  Return either minutes or seconds of String parameter based on the index
}                                   // End of method

Testcode:

Probieren Sie es hier aus.

class M{
  String c(String a,String b){long s=x(b,1)-x(a,1)+(x(b,0)-x(a,0))*60,m=s%60;return(s/60)+":"+(m>9?m:"0"+m);}long x(String s,int i){return new Long(s.split(":")[i]);}

  public static void main(String[] a){
    M m = new M();
    System.out.println(m.c("0:00", "0:01"));
    System.out.println(m.c("0:55", "1:00"));
    System.out.println(m.c("1:45", "3:15"));
  }
}

Ausgabe:

0:01
0:05
1:30

TXR Lisp, 101 Bytes

$ txr -e '(awk (:let (s "%M:%S"))
               ((mf (time-parse s))
                (prn (time-string-local (- [f 1].(time-utc) [f 0].(time-utc)) s))))'
13:49 14:49 
01:00
0:13 1:47
01:34
5:01 5:59
00:58
6:00 6:00
00:00
6:00 5:00
59:00

Kondensiert: (awk(:let(s"%M:%S"))((mf(time-parse s))(prn(time-string-local(-[f 1].(time-utc)[f 0].(time-utc))s))))

Rubin , 91 Bytes

require'time';t=Time;d=t.parse($*[1])-t.parse($*[0]);puts t.at(d.to_i).utc.strftime '%H:%M'

Probieren Sie es online!

Übernimmt Eingaben von Befehlszeilenargumenten.

Aufruf:

ruby outatime.rb $A $B

Beispiel:

ruby outatime.rb 1:45 3:15

Ausgabe:

01:30

PowerShell 47 Bytes

param($s,[timespan]$f)($f-$s).ToString("h\:mm")

Einfache Zeitberechnung und Umrechnung auf Stunden- und Sekundenschnur.

JavaScript, 88 Bytes

a=>b=>{c=a.split`:`,d=b.split`:`;return +c[0]-d[0]-d[1]>c[1]?1:0+":"+(+c[1]+60-d[1])%60}

Probieren Sie es online!

Erläuterung:

Teilt die Eingaben am Doppelpunkt auf

c=a.split`:`,d=b.split`:`;

Konvertiert einen String in einen int

+c[0]

Ruft den Minutenwert ab

+c[0]-d[0]-d[1]>c[1]?1:0

Ruft den zweiten Wert ab

(+c[1]+60-d[1])%60

Gibt die Zeichenfolge Minuten: Sekunden zurück

return +c[0]-d[0]-d[1]>c[1]?1:0+":"+(+c[1]+60-d[1])%60