Il programma

Si sono dati due stringhe, A e B . A è la posizione corrente in cui si trova il timer e B è la posizione in cui il timer si fermerà. Entrambe le stringhe sono nel formato m: ss . È necessario scrivere un programma che determini la quantità di tempo che deve essere formattata come m: ss o mm: ss .

Esempio

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

Excel, 6 byte

=B1-A1

Supponendo che A sia nella cella A1e B sia nella cellaB1

MATL , 17 7 byte

YOd15XO

L'input è una matrice di celle di stringhe, nella forma {'1:45' '3:15'}o {'1:45', '3:15'}.

Provalo online!

Spiegazione

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

Provalo online!

Spiegazione: utilizzo di "1:45 3:15" come test case (ultimo esempio). Mostro i passaggi intermedi tra virgolette.

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.

Si noti che non controllo se il valore minuto ha bisogno di un'imbottitura zero, perché l'OP ha dichiarato che il valore massimo per m è 9.

Di seguito è la mia risposta originale di 44 byte, che ha utilizzato il datecomando per trasformare il tempo totale rimasto in secondi nel m:ssformato.

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

Python 2, 90 87 83 80 byte

Accetta input come "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)

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

Legge i tempi separati da spazio da STDIN.

Provalo online .

Lotto, 74 byte

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

La sostituzione di :in the time con lo *60+1converte in un'espressione che calcola il numero di secondi. Batch interpreta gli zeri iniziali come ottali, quindi antepongo 1a i secondi per garantire la conversione decimale; per fortuna i due si 1annullano.

C, 112 100 byte

Grazie a @betseg per aver salvato 11 byte e grazie a @Johan du Toit per aver salvato un 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);}

Provalo online!

MySQL, 13 22 byte

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

si aspetta i tempi in Ae B.

Utilità Bash + GNU, 43

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

Provalo online .

Spiegazione

         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

Nota che l' dcespressione si divide per 60, perché datelegge l'input come H: MM anziché M: SS.

ECMAScript 6, 99 91 85 byte

Linea singola:

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

Leggermente formattato:

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

Sento che potrebbero esserci dei risparmi lì dentro .. ma al momento non li vedo.

Modifica: ottimi suggerimenti nei commenti.

PHP, 55 53 byte

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

accetta input dagli argomenti della riga di comando

C #, 72 byte

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

Accetta input come stringhe. b="3:15" a="1:45".

Spiegazione:

Poiché DateTime.Parse()restituisce una data in hh:mm:ssformato, sono in grado di analizzare il risultato in una stringa utilizzando +"", quindi tagliare il finale :00.

Funziona con hh:mmperché ci sono entrambi 60 secondi in un minuto e 60 minuti in un'ora.

0:01 0:00 ritorna 0:01

1:00 0:55 ritorna 0:05

3:15 1:45 ritorna 1:30

Rebol, 5 byte

b - a

Supponendo che non ho perso nessuna regola ..

Rebol ha integrato l'aritmetica per un certo numero di tipi di dati letterali. Questo vale anche per i suoi discendenti come il Rosso

Pyth, 47 45 44 40 byte

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

Prende l'input separato da newline.

Pyth non aveva tempo incorporato utile per questo. Ho provato alcune cose fantasiose di eval () ma a quanto pare Pyth non può valutare cose con *o zero iniziali di sorta. Questo è durato molto più di quanto sperassi. Alcuni byte vengono spesi per l'aggiunta di uno zero iniziale all'output. Almeno sono più basso di bash. Aggiungerà spiegazione se richiesto.

Prova questo!

soluzione alternativa, 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

Provalo online!

Ma mi chiedo se ci sono alcune funzioni di libreria per questo

EDIT: rimossa l'importazione, risolto anche un errore in cui mostrava m: s invece di m: ss

Inoltre, versione ben formattata:

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: golf off (30?) Byte grazie a Laikoni! Ho anche giocato a golf con altri misc. 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

Uso:

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

Vedendo l'esempio di PostGres in precedenza, mi sono reso conto che non avevo visto molti tentativi di golf in SQL, quindi ho provato a farlo in T-SQL. Ora so perché non vedi molto golf in SQL: D

CJam , 34 33 25 byte

Risparmiato 8 byte grazie a Martin Ender!

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

Provalo online!

Spiegazione

{             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

Sono ancora nuovo a programmare il golf, quindi se qualcuno ha qualche suggerimento, lo apprezzerei.

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

Pyth, 28

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

Provatelo .

Spiegazione

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

Spiegazione:

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

Codice di prova:

Provalo qui.

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

Produzione:

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

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

Rubino , 91 byte

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

Provalo online!

Accetta input dagli argomenti della riga di comando.

Invocazione:

ruby outatime.rb $A $B

Esempio:

ruby outatime.rb 1:45 3:15

Produzione:

01:30

PowerShell 47 byte

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

Matematica semplice e conversione alla stringa di ore e secondi.

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}

Provalo online!

Spiegazione:

Divide gli input sui due punti

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

Converte la stringa in int

+c[0]

Ottiene il valore dei minuti

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

Ottiene il secondo valore

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

Restituisce i minuti della stringa: secondi

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