El programa

Se le da dos cadenas, A y B . A es la posición actual en la que se encuentra su temporizador, y B es la posición en la que se detendrá su temporizador. Ambas cadenas tienen el formato m: ss . Debe escribir un programa que determine la cantidad de tiempo restante que también debe formatearse como m: ss o mm: ss .

Ejemplo

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

Excel, 6 bytes

=B1-A1

Asumiendo que A está en la celda A1y B está en la celdaB1

MATL , 17 7 bytes

YOd15XO

La entrada es una matriz de celdas de cadenas, en forma {'1:45' '3:15'}o {'1:45', '3:15'}.

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Explicación: usando "1:45 3:15" como caso de prueba (último ejemplo). Muestro pasos intermedios entre comillas.

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.

Tenga en cuenta que no verifico si el valor minuto necesita cero relleno, porque el OP declaró que el valor máximo para m9.

A continuación se muestra mi respuesta original de 44 bytes, que usaba el datecomando para convertir el tiempo total restante en segundos al m:ssformato.

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

Python 2, 90 87 83 80 bytes

Toma entrada como "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)

Pruébalo en línea

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

Lee tiempos separados por espacios de STDIN.

Pruébalo en línea .

Lote, 74 bytes

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

Reemplazar el :en el tiempo con lo *60+1convierte en una expresión que calcula el número de segundos. Batch interpreta los ceros a la izquierda como octales, así que antepongo a 1a los segundos para asegurar la conversión decimal; Afortunadamente, los dos se 1cancelan.

C, 112 100 bytes

¡Gracias a @betseg por guardar 11 bytes y gracias a @Johan du Toit por guardar 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);}

Pruébalo en línea!

MySQL, 13 22 bytes

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

espera los tiempos en Ay B.

Bash + GNU utilidades, 43

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

Pruébalo en línea .

Explicación

         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

Tenga en cuenta que la dcexpresión se divide por 60, porque datelee la entrada como H: MM en lugar de M: SS.

ECMAScript 6, 99 91 85 bytes

Linea sola:

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

Ligeramente formateado:

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

Siento que podría haber algunos ahorros allí ... pero no los estoy viendo en este momento.

Editar: excelentes sugerencias en los comentarios.

PHP, 55 53 bytes

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

toma datos de los argumentos de la línea de comandos

C #, 72 bytes

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

Toma la entrada como cadenas. b="3:15" a="1:45".

Explicación:

Debido a que DateTime.Parse()devuelve una fecha en hh:mm:ssformato, puedo analizar el resultado en una cadena usando +"", luego recortar el final:00 .

Esto funciona hh:mmporque hay 60 segundos en un minuto y 60 minutos en una hora.

0:01 0:00 devoluciones 0:01

1:00 0:55 devoluciones 0:05

3:15 1:45 devoluciones 1:30

Rebol, 5 bytes

b - a

Asumiendo que no me perdí ninguna regla ...

Rebol tiene aritmética incorporada para varios tipos de datos literales. Esto también se aplica a sus descendientes como Red

Pyth, 47 45 44 40 Bytes

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

Toma la entrada separada por nuevas líneas.

Pyth no tenía incorporaciones de tiempo útiles para esto. Intenté algunas cosas elegantes de eval (), pero aparentemente Pyth no puede evaluar cosas con *ceros iniciales ni ningún otro. Esto se hizo mucho más largo de lo que esperaba. Se gastan algunos bytes en agregar un cero inicial a la salida. Al menos soy más bajo que bash. Agregará explicación si se le solicita.

¡Prueba esto!

solución alternativa, 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

Pruébalo en línea!

Pero me pregunto si hay algunas funciones de biblioteca para esto

EDITAR: Se eliminó la importación, también se corrigió un error donde mostraba m: s en lugar de m: ss

Además, versión bien formateada:

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 (30?) Bytes gracias a Laikoni! También golf algunos otros misceláneos. 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

Uso:

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

Al ver el ejemplo de PostGres anteriormente, me di cuenta de que no había visto muchos intentos de golf en SQL, así que lo intenté en T-SQL. Ahora sé por qué no ves mucho golf en SQL: D

CJam , 34 33 25 bytes

¡Ahorró 8 bytes gracias a Martin Ender!

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

Pruébalo en línea!

Explicación

{             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

Todavía soy nuevo en el código de golf, así que si alguien tiene alguna sugerencia, lo agradecería.

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

Intentalo .

Explicación

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

Explicación:

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

Código de prueba:

Pruébalo aquí.

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

Salida:

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

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

Ruby , 91 bytes

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

Pruébalo en línea!

Toma información de los argumentos de la línea de comandos.

Invocación:

ruby outatime.rb $A $B

Ejemplo:

ruby outatime.rb 1:45 3:15

Salida:

01:30

PowerShell 47 Bytes

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

Matemáticas simples de intervalo de tiempo y conversión a una secuencia de hora y segundos.

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}

Pruébalo en línea!

Explicación:

Divide las entradas en el colon

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

Convierte una cadena a int

+c[0]

Obtiene el valor minuto

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

Obtiene el segundo valor

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

Devuelve la cadena minutos: segundos

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