Program

Dostępne są dwie struny, A i B . A to bieżąca pozycja, w której znajduje się stoper, a B to pozycja, w której stoper się zatrzyma. Oba ciągi mają format m: ss . Musisz napisać program, który określa pozostały czas, który również powinien być sformatowany jako m: ss lub mm: ss .

Przykład

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

Excel, 6 bajtów

=B1-A1

Zakładając, że A jest w komórce, A1a B w komórceB1

MATL , 17 7 bajtów

YOd15XO

Dane wejściowe to tablica komórek ciągów znaków w postaci {'1:45' '3:15'}lub {'1:45', '3:15'}.

Wypróbuj online!

Wyjaśnienie

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 bajtów

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

Wypróbuj online!

Objaśnienie: użycie „1:45 3:15” jako przypadku testowego (ostatni przykład). W cudzysłowie pokazuję kroki pośrednie.

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.

Zauważ, że nie sprawdzam, czy wartość minutowa wymaga zerowania, ponieważ OP stwierdził, że maksymalna wartość mwynosi 9.

Poniżej znajduje się moja oryginalna 44-bajtowa odpowiedź, która użyła datepolecenia, aby zmienić całkowity czas w sekundach na m:ssformat.

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

Python 2, 90 87 83 80 bajtów

Przyjmuje dane wejściowe jak "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)

Wypróbuj online

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

Odczytuje czasy STDIN oddzielone spacjami.

Wypróbuj online .

Partia, 74 bajty

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

Zastąpienie :in the time *60+1konwertuje go na wyrażenie, które oblicza liczbę sekund. Batch interpretuje początkowe zera jako ósemkowe, więc wstawiam a 1na sekundy, aby zapewnić konwersję dziesiętną; na szczęście oba 1s anulowane.

C, 112 100 bajtów

Podziękowania dla @betseg za uratowanie 11 bajtów i podziękowania dla @Johan du Toit za uratowanie jednego bajtu!

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

Wypróbuj online!

MySQL, 13 22 bajtów

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

oczekuje czasów w Ai B.

Narzędzia Bash + GNU, 43

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

Wypróbuj online .

Wyjaśnienie

         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

Zwróć uwagę, że dcwyrażenie dzieli przez 60, ponieważ dateodczytuje dane wejściowe jako H: MM zamiast M: SS.

ECMAScript 6, 99 91 85 bajtów

Pojedyncza linia:

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

Lekko sformatowany:

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

Wydaje mi się, że mogą tam być jakieś oszczędności ... ale obecnie ich nie widzę.

Edytuj - doskonałe sugestie w komentarzach.

PHP, 55 53 bajtów

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

pobiera dane wejściowe z argumentów wiersza poleceń

C #, 72 bajty

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

Pobiera dane wejściowe jako ciągi znaków. b="3:15" a="1:45".

Wyjaśnienie:

Ponieważ DateTime.Parse()zwraca datę w hh:mm:ssformacie, jestem w stanie przeanalizować wynik w ciągu za pomocą +"", a następnie przyciąć końcowe :00.

Działa to, hh:mmponieważ zarówno 60 sekund na minutę, jak i 60 minut na godzinę.

0:01 0:00 zwraca 0:01

1:00 0:55 zwraca 0:05

3:15 1:45 zwraca 1:30

Rebol, 5 bajtów

b - a

Zakładając, że nie przegapiłem żadnych zasad ..

Rebol ma wbudowaną arytmetykę dla wielu dosłownych typów danych. Dotyczy to również jego potomków, takich jak Czerwony

Pyth, 47 45 44 40 Bajtów

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

Oddziela dane wejściowe od nowych linii.

Pyth nie miał wbudowanego czasu przydatnego do tego. Próbowałem trochę fantazyjnych rzeczy eval (), ale najwyraźniej Pyth nie może ewaluować rzeczy z *zerami wiodącymi. Trwało to znacznie dłużej, niż się spodziewałem. Sporo bajtów wydaje się na dodanie wiodącego zera do wyniku. Przynajmniej jestem krótszy niż bash. Na żądanie doda wyjaśnienie.

Spróbuj tego!

alternatywne rozwiązanie, 48 bajtów

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

Haskell, 98 127 86 bajtów

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

Wypróbuj online!

Ale zastanawiam się, czy są do tego jakieś funkcje biblioteczne

EDYCJA: Usunięto import, naprawiono także błąd, w którym pokazywał m: s zamiast m: ss

Również dobrze sformatowana wersja:

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: Golfed off (30?) Bajtów dzięki Laikoni! Grał także w inne gry. bajty.

T-SQL, 238 bajtów

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

Stosowanie:

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

Widząc wcześniej przykład PostGres, zdałem sobie sprawę, że nie widziałem wielu prób gry w golfa w SQL, więc spróbowałem w T-SQL. Teraz wiem, dlaczego nie widzisz dużo golfa w SQL: D

CJam , 34 33 25 bajtów

Zaoszczędź 8 bajtów dzięki Martinowi Enderowi!

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

Wypróbuj online!

Wyjaśnienie

{             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 bajty

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

Python, 160 bajtów

Nadal jestem nowy w kodowaniu golfa, więc jeśli ktoś ma jakieś sugestie, byłbym wdzięczny.

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 bajtów

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

Spróbować .

Wyjaśnienie

                   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 bajty

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

Wyjaśnienie:

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

Kod testowy:

Wypróbuj tutaj.

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

Wydajność:

0:01
0:05
1:30

TXR Lisp, 101 bajtów

$ 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

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

Ruby , 91 bajtów

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

Wypróbuj online!

Pobiera dane wejściowe z argumentów wiersza poleceń.

Wezwanie:

ruby outatime.rb $A $B

Przykład:

ruby outatime.rb 1:45 3:15

Wydajność:

01:30

PowerShell 47 bajtów

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

Prosta matematyka przedziału czasowego i obejmująca ciąg godzin i sekund.

JavaScript, 88 bajtów

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}

Wypróbuj online!

Wyjaśnienie:

Dzieli dane wejściowe na jelicie grubym

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

Konwertuje ciąg na int

+c[0]

Pobiera wartość minut

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

Pobiera drugą wartość

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

Zwraca ciąg minut: sekundy

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