Chương trình

Bạn đang đưa ra hai chuỗi, Một và B . A là vị trí hiện tại mà bộ hẹn giờ của bạn đang ở và B là vị trí mà bộ hẹn giờ của bạn sẽ dừng lại. Cả hai chuỗi có định dạng m: ss . Bạn phải viết một chương trình xác định lượng thời gian còn lại cũng sẽ được định dạng là m: ss hoặc mm: ss .

Thí dụ

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

Excel, 6 byte

=B1-A1

Giả sử A ở trong ô A1và B ở trong ôB1

MATL , 17 7 byte

YOd15XO

Đầu vào là một mảng ô của các chuỗi, ở dạng {'1:45' '3:15'}hoặc {'1:45', '3:15'}.

Hãy thử trực tuyến!

Giải trình

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 byte

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

Hãy thử trực tuyến!

Giải thích: sử dụng "1:45 3:15" làm trường hợp thử nghiệm (ví dụ cuối cùng). Tôi hiển thị các bước trung gian trong dấu ngoặc kép.

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.

Lưu ý rằng tôi không kiểm tra xem giá trị phút có cần đệm không, bởi vì OP tuyên bố rằng giá trị tối đa mlà 9.

Dưới đây là câu trả lời 44 byte ban đầu của tôi, đã sử dụng datelệnh để biến tổng thời gian còn lại tính bằng giây thành m:ssđịnh dạng.

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

Python 2, 90 87 83 80 byte

Đưa đầu vào như thế nào "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)

Dùng thử trực tuyến

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

Đọc thời gian phân tách không gian từ STDIN.

Hãy thử trực tuyến .

Mẻ, 74 byte

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

Thay thế :thời gian bằng *60+1chuyển đổi nó thành một biểu thức tính số giây. Batch diễn giải các số 0 đứng đầu dưới dạng bát phân vì vậy tôi trả trước một 1giây để đảm bảo chuyển đổi thập phân; may mắn là hai 1s hủy bỏ.

C, 112 100 byte

Cảm ơn @betseg vì đã lưu 11 byte và cảm ơn @Johan du Toit vì đã lưu một 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);}

Hãy thử trực tuyến!

MySQL, 13 22 byte

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

mong đợi thời gian trong Avà B.

Tiện ích Bash + GNU, 43

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

Hãy thử trực tuyến .

Giải trình

         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

Lưu ý dcbiểu thức chia cho 60, vì dateđọc đầu vào là H: MM thay vì M: SS.

ECMAScript 6, 99 91 85 byte

Dòng đơn:

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

Hơi định dạng:

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

Tôi cảm thấy có thể có một số tiền tiết kiệm trong đó .. nhưng hiện tại tôi không thấy chúng.

Chỉnh sửa - đề xuất xuất sắc trong các ý kiến.

PHP, 55 53 byte

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

lấy đầu vào từ các đối số dòng lệnh

C #, 72 byte

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

Lấy đầu vào dưới dạng chuỗi. b="3:15" a="1:45".

Giải trình:

Vì DateTime.Parse()trả về một ngày ở hh:mm:ssđịnh dạng, tôi có thể phân tích kết quả thành một chuỗi bằng cách sử dụng +"", sau đó cắt theo dõi :00.

Điều này hoạt động với hh:mmvì có cả 60 giây trong một phút và 60 phút trong một giờ.

0:01 0:00 trả lại 0:01

1:00 0:55 trả lại 0:05

3:15 1:45 trả lại 1:30

Rebol, 5 byte

b - a

Giả sử tôi đã không bỏ lỡ bất kỳ quy tắc nào ..

Rebol có số học tích hợp cho một số loại dữ liệu bằng chữ. Điều này cũng áp dụng cho con cháu của nó như Đỏ

Bình thường, 47 45 44 40 byte

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

Đưa đầu vào được phân tách bằng dòng mới.

Pyth không có thời gian tích hợp hữu ích cho việc này. Tôi đã thử một số công cụ eval () lạ mắt nhưng Pyth không thể tránh khỏi những thứ không có *hoặc bất kỳ số 0 hàng đầu nào. Điều này đã lâu hơn tôi mong đợi. Khá nhiều byte được dành cho việc thêm số 0 vào đầu ra. Ít nhất là tôi ngắn hơn bash. Sẽ thêm lời giải thích nếu được hỏi.

Thử đi!

giải pháp thay thế, 48 byte

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

Haskell, 98 127 86 byte

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

Hãy thử trực tuyến!

Nhưng tôi tự hỏi nếu có một số chức năng thư viện cho việc này

EDIT: Đã xóa nhập, cũng đã sửa một lỗi trong đó hiển thị m: s thay vì m: ss

Ngoài ra, phiên bản được định dạng tốt:

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: Đã tắt (30?) Byte nhờ Laikoni! Cũng đánh golf một số linh tinh khác. byte.

T-SQL, 238 byte

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

Sử dụng:

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

Nhìn thấy ví dụ PostGres trước đó tôi nhận ra rằng tôi đã không thấy nhiều nỗ lực chơi gôn trong SQL nên tôi đã thử nó trong T-SQL. Bây giờ tôi biết tại sao bạn không thấy chơi golf nhiều trong SQL: D

CJam , 34 33 25 byte

Đã lưu 8 byte nhờ Martin Ender!

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

Hãy thử trực tuyến!

Giải trình

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

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

Python, 160 byte

Tôi vẫn chưa quen với môn golf, vì vậy nếu có ai có bất cứ đề nghị nào, tôi sẽ đánh giá cao nó.

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 byte

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

Bình thường, 28

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

Hãy thử nó .

Giải trình

                   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 byte

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

Giải trình:

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

Mã kiểm tra:

Hãy thử nó ở đây.

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

Đầu ra:

0:01
0:05
1:30

TXR Lisp, 101 byte

$ 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

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

Ruby , 91 byte

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

Hãy thử trực tuyến!

Lấy đầu vào từ các đối số dòng lệnh.

Cầu nguyện:

ruby outatime.rb $A $B

Thí dụ:

ruby outatime.rb 1:45 3:15

Đầu ra:

01:30

PowerShell 47 byte

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

Toán thời gian đơn giản và chuyển đổi thành chuỗi giờ và giây.

JavaScript, 88 byte

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}

Hãy thử trực tuyến!

Giải trình:

Tách các đầu vào trên đại tràng

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

Chuyển đổi chuỗi thành int

+c[0]

Nhận giá trị phút

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

Nhận giá trị thứ hai

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

Trả về chuỗi phút: giây

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