Program

A ve B olarak iki karakter verilir . A , zamanlayıcınızın bulunduğu geçerli konumdur ve B zamanlayıcınızın duracağı konumdur. Her iki dize de m: ss biçimindedir . Kalan süreyi belirleyen ve ayrıca m: ss veya mm: ss olarak biçimlendirilmesi gereken bir program yazmalısınız .

Örnek

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

Excel, 6 Bayt

=B1-A1

A hücresinde A1ve B hücresinde olduğunu varsayalımB1

Matl , 17 7 bayt

YOd15XO

Giriş, {'1:45' '3:15'}veya biçimindeki bir hücre dizesi dizisidir {'1:45', '3:15'}.

Çevrimiçi deneyin!

açıklama

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 bayt

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

Çevrimiçi deneyin!

Açıklama: Test durumu olarak "1:45 3:15" kullanarak (son örnek). Ara adımları tırnak içinde gösteriyorum.

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.

Dakika değerinin sıfır yastığa ihtiyacı olup olmadığını kontrol etmediğimi unutmayın, çünkü OP için maksimum değer m 9 .

Aşağıda, orjinal 44 baytlık cevabım var, bu dateda saniye cinsinden kalan süreyi m:ssformata çevirmek için komutu kullandı .

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

Python 2, 90 87 83 80 bayt

Gibi girdi alır "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)

Çevrimiçi deneyin

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

STDIN'den boşlukla ayrılmış zamanları okur.

Çevrimiçi deneyin .

Toplu iş, 74 bayt

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

:Zamanın içindeki değeri değiştirmek, *60+1saniye sayısını hesaplayan bir ifadeye dönüştürür. Batch, baştaki sıfırları sekizli olarak yorumlar, böylece 1ondalık dönüştürmeyi sağlamak için a saniyesini hazırlarım ; Neyse ki iki 1s iptal edildi.

C, 112 100 bayt

11 byte tasarruf için @ betseg ve bir byte tasarruf için @Johan du Toit sayesinde!

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

Çevrimiçi deneyin!

MySQL, 13 22 bayt

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

Ave içindeki zamanları bekler B.

Bash + GNU yardımcı programları, 43

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

Çevrimiçi deneyin .

açıklama

         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

dcİfadenin 60'a bölündüğünü unutmayın , çünkü dategirişi M: SS yerine H: MM olarak okur.

ECMAScript 6, 99 91 85 bayt

Tek satır:

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

Hafifçe biçimlendirilmiş:

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

Orada biraz tasarruf olabileceğini hissediyorum .. ama şu anda onları göremiyorum.

Düzenleme - yorumlarda mükemmel öneriler.

PHP, 55 53 bayt

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

komut satırı argümanlarından girdi alır

C #, 72 bayt

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

Girdiyi dizge olarak alır. b="3:15" a="1:45".

Açıklama:

Çünkü DateTime.Parse()bir tarihi döndüren hh:mm:ssbiçimi, ben kullanarak bir dizeye sonucu ayrıştırmak mümkün duyuyorum +""sondaki Döşeme sonra,:00 .

Bu çalışır hh:mmçünkü bir dakikada 60 saniye ve bir saatte 60 dakikadır.

0:01 0:00 döner 0:01

1:00 0:55 döner 0:05

3:15 1:45 döner 1:30

Rebol, 5 bayt

b - a

Sanırım hiçbir kuralı kaçırmadım.

Rebol, birkaç değişmez veri türü için yerleşik bir aritmetik özelliğine sahiptir. Bu aynı zamanda Kırmızı gibi torunları için de geçerlidir.

Pyth, 47 45 44 40 Bayt

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

Girdiyi yeni satırlarla ayırarak alır.

Pyth, bunun için faydalı zamana sahip değildi. Bazı fantezi eval () denemelerini denedim ama doğru bir şekilde Pyth, *hiçbir şekilde öncü sıfırlarla şeyleri değerlendiremez . Bu umduğumdan çok daha uzun sürdü. Oldukça bazı baytlar, çıktıya öncü bir sıfır eklemeye harcanır. En azından ben bashtan kısayım. İstenirse açıklama ekleyecektir.

Bunu dene!

alternatif çözüm, 48 Bayt

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

Haskell, 98 127 86 Bayt

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

Çevrimiçi deneyin!

Ama bunun için bazı kütüphane fonksiyonları olup olmadığını merak ediyorum

EDIT: Alınan içe aktarma kaldırıldı, ayrıca m: ​​ss yerine m: s gösterdiği bir hata düzeltildi.

Ayrıca, iyi biçimlendirilmiş sürüm:

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: Laikoni sayesinde golf oynadı (30?) Bayt! Ayrıca diğer bazı misc golf. bayt.

T-SQL, 238 bayt

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

Kullanımı:

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

PostGres örneğini daha önce görünce, SQL'de çok fazla golf denemesi görmediğimi fark ettim, bu yüzden T-SQL'de denedim. Şimdi neden SQL'de çok fazla golf görmediğinizi biliyorum : D

CJam , 34 33 25 bayt

Martin Ender sayesinde 8 bayt kaydedildi!

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

Çevrimiçi deneyin!

açıklama

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

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

Python, 160 bayt

Golf kodları konusunda hala yeniyim, bu yüzden herhangi bir önerisi varsa, memnun olurum.

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 bayt

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

Dene .

açıklama

                   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 bayt

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

Açıklama:

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

Test kodu:

Burada dene.

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

Çıktı:

0:01
0:05
1:30

TXR Lisp, 101 bayt

$ 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

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

Ruby , 91 bayt

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

Çevrimiçi deneyin!

Komut satırı argümanlarından girdi alır.

çağırma:

ruby outatime.rb $A $B

Örnek:

ruby outatime.rb 1:45 3:15

Çıktı:

01:30

PowerShell 47 Bayt

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

Basit zaman dilimi matematik ve saat ve saniye dize kapsayan.

JavaScript, 88 bayt

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}

Çevrimiçi deneyin!

Açıklama:

Kolondaki girişleri böler

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

Dize int dönüştürür

+c[0]

Dakika değerini alır

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

İkinci değeri alır

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

Dizi dakikalarını döndürür: saniye

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