Desafío

Dada una hora y una zona horaria como entrada, genera la hora en esa zona horaria.

Hora

El tiempo se dará en formato de 24 horas así:

hh:mm

Donde hh es la hora de dos dígitos y mm es el minuto de dos dígitos. Tenga en cuenta que la hora y el minuto siempre se rellenarán con ceros de la siguiente manera:

06:09

Todos los horarios indicados son en UTC + 00: 00.

Las horas en su salida no tienen que ser rellenadas con ceros, pero su tiempo debe estar en formato de 24 horas

Zona horaria

La zona horaria se dará en el siguiente formato:

UTC±hh:mm

Donde ± va a ser a + o a - y hh, es la hora de dos dígitos y mm es el minuto de dos dígitos (nuevamente, estos se rellenarán con ceros).

Para encontrar el tiempo en esa zona horaria, puede sumar (si el símbolo es +) o restar (si el símbolo es -) el tiempo después del UTC ± del tiempo ingresado.

Por ejemplo, si la entrada fue 24:56y UTC-02:50, restarías 2 horas y 50 minutos de 24:56:

24:56
02:50 -
-----
22:06

La salida sería 22:06.

Ejemplos

Chicago

Input:  08:50 and UTC-06:00
Output: 02:50

Katmandú

Input:  09:42 and UTC+05:45
Output: 15:27

Samoa

Input:  06:42 and UTC+13:00
Output: 19:42

Hawai

Input:  02:40 and UTC-10:00
Output: 16:40

Tenga en cuenta que esto se ha ido al día anterior.

Tokio

Input:  17:25 and UTC+09:00
Output: 02:25

Tenga en cuenta que esto se ha ido al día siguiente.

Reglas

No debe usar ninguna función de fecha o biblioteca incorporada.

Suponga que todas las entradas serán tiempos válidos y compensaciones de tiempo.

La zona horaria estará en el rango UTC-24:00de UTC+24:00inclusivo.

En el caso de la medianoche y media , la representación correcta debería ser 00:30, no 24:30 .

Victorioso

El código más corto en bytes gana.

APL (Dyalog APL) , 45 bytes

Expresión

Toma dos cadenas como argumento correcto.

24 60⊤∘⍎∘⍕('+-'∩⍕),'/',(0 60⊥2⊃':'⎕VFI ¯5∘↑)¨

Pruébalo en línea!

Explicación

24 60⊤la conversión de número a base a ₂₄ b ₆₀

∘ de

⍎ la evaluación

∘ de

⍕ el formateado (es decir, aplanado con espacios de separación)

('+-'∩⍕) intersección de "+ -" y la entrada formateada (esto extrae el signo más o menos)

, seguido por

(... )¨lo siguiente para cada una de las entradas (el tiempo y el desplazamiento)

 0 60⊥la una _∞ b ₆₀ conversión de número -to de

 2⊃ el segundo elemento de

 ':'⎕VFIla, utilizando dos puntos como separador de campo, V erified y F ixed I Nput de

 ¯5∘↑ los últimos cinco caracteres ("hh: mm")

Paso a paso en "17:25" y "UTC + 09: 00"

La expresión del lado izquierdo en los datos del lado derecho, da los datos de la siguiente línea.

                       '17: 25 '' UTC + 09: 00 '
                      / / \ \
(...) ¨ aplica el tren de funciones a ambas entradas
                    / / \ \
¯5∘ ↑ '17: 25 '' UTC + 09: 00 '
':' ⎕VFI '17: 25 ''09: 00' 
2⊃ (1 1) (17 25) (1 1) (9 0)
0 60⊥ ​​17 25 9 0
                      1045 540
                       \ \ / /
Aquí es donde ¨ se detiene, y la ejecución continúa en la lista resultante
                         \ \ / /
'/', 1045 540
('+ -' ∩⍕), '/' 1045540
⍕ '+' '/' 1045 540
⍎ '+ / 1045 540'
24 60⊤ 1585
                              2 25

C, 109 bytes

a,b,c;f(char*t,char*z){for(c=0;z[3];t=z+=3)sscanf(t,"%d:%d",&a,&b),c+=b+a*60;printf("%d:%02d",c/60%24,c%60);}

Invoque de la siguiente manera:

int main() { f("17:25", "UTC+09:00"); }

JavaScript (ES6), 101 bytes

(t,z,g=s=>+(s[3]+s[7]+s[8])+s.slice(3,6)*60,m=g('UTC+'+t)+g(z)+1440)=>(m/60%24|0)+':'+(m/10%6|0)+m%10

Sería 121 bytes si rellenara las horas.

Python 2, 129 bytes

def T(t,a):f=[int.__add__,int.__sub__]["-"in a];m=f(int(t[3:5]),int(a[7:9]));print`f(int(t[0:2])+m/60,int(a[4:6]))%24`+":"+`m%60`

Llamar como T("02:45", "UTC-05:33")

Python 2, 84 bytes

def f(t,z):i=int;r=60*(i(t[:2])+i(z[3:6]))+i(t[3:])+i(z[3]+z[7:]);print r/60%24,r%60

Todos los casos de prueba están en ideone

El formato de salida está separado por espacios, sin ceros a la izquierda.

Java 201 bytes

String T(String t,String z){return(24+Integer.valueOf(t.substring(0,2))+Integer.valueOf((String)z.subSequence(3,6)))%24+":"+(60+Integer.valueOf(t.substring(3,5))+Integer.valueOf(z.substring(7,9)))%60;}

Llamado como T ("12:00", "UTC + 02: 40")

Insensible a la lógica,

String T(String t, String z) { 
    int i = (24 + Integer.valueOf(t.substring(0, 2)) + Integer.valueOf((String) z.subSequence(3, 6))) % 24;
    int j = (60 + Integer.valueOf(t.substring(3, 5)) + Integer.valueOf(z.substring(7, 9))) % 60;
    return i + ":" + j;
}

¡Cualquier ayuda para obtener menos de 200 sería apreciada!

Ruby, 95 bytes

g=->s{"60*"+s.scan(/\d+/).map(&:to_i)*?+}
f=->t,z{r=eval(g[t]+z[3]+g[z]);print r/60%24,?:,r%60}

Uso

f[gets,gets]

Entradas (ejemplo)

08:50
UTC-06:00

Javascript (ES6), 93 92 bytes

t=>((t=eval(t.replace(/.*?(.)?(..):(..)/g,'$1($2*60+$3)+720')))/60%24|0)+':'+(t/10%6|0)+t%10

Casos de prueba

let f =
t=>((t=eval(t.replace(/.*?(.)?(..):(..)/g,'$1($2*60+$3)+720')))/60%24|0)+':'+(t/10%6|0)+t%10

console.log(f("08:50 UTC-06:00")); //  2:50
console.log(f("09:42 UTC+05:45")); // 15:27
console.log(f("06:42 UTC+13:00")); // 19:42
console.log(f("02:40 UTC-10:00")); // 16:40
console.log(f("17:25 UTC+09:00")); //  2:25

Java 156 150 149 147 142 bytes

t->z->{Integer H=100,T=H.valueOf(t.replace(":","")),Z=H.valueOf(z.replace(":","").substring(3)),c=(T/H+Z/H+24)*60+T%H+Z%H;return c/60%24+":"+c%60;}

Casos de prueba y sin golf

import java.util.function.BiFunction;

public class Main {
    public static void main(String[] args) {

        BiFunction<String,String,String> f = (t,z)->{
            Integer H = 100, // Hundred, used several times, shorter as variable
                    T = H.valueOf(t.replace(":","")), // as int (HHMM)
                    Z = H.valueOf(z.replaceAll("[UTC:]","")), // as int (-HHMM)
                    c = (T/H + Z/H + 24) * 60 + T%H + Z%H; // transform into minutes
            return c/60%24+":"+c%60;
        };

        test(f, "08:50", "UTC-06:00", "02:50");
        test(f, "09:42", "UTC+05:45", "15:27");
        test(f, "03:42", "UTC-05:45", "21:57");
        test(f, "06:42", "UTC+13:00", "19:42");
        test(f, "02:40", "UTC-10:00", "16:40");
        test(f, "17:25", "UTC+09:00", "02:25");
    }

    private static void test(BiFunction<String,String,String> f, String time, String zone, String expected) {
        // Padding is allowed. Make sure the padding is skipped for the test, then.
        String result = String.format("%2s:%2s", (Object[])f.apply(time, zone).split(":")).replace(" ","0");
        if (result.equals(expected)) {
            System.out.printf("%s + %s: OK%n", time, zone);
        } else {
            System.out.printf("%s + %s: Expected \"%s\", got \"%s\"%n", time, zone, expected, result);
        }

    }
}

Virutas

• 150 -> 149: a/H*60+b/H*60->(a/H+b/H)*60
• 149 -> 147: (T/H+Z/H)*60+1440-> (T/H+Z/H+24)*60.
• 147 -> 142: z.replace(":","").substring(3)->z.replaceAll("[UTC:]","")

C # 214 205 183 Bytes

string f(char[]t,char[]u){int s=~(u[3]-45),z=48,m=(t[3]-z)*10+t[4]-z+((u[7]-z)*10+u[8]-z)*s,h=(t[0]-z)*10+t[1]-z+((u[4]-z)*10+u[5]-z)*s+m/60+(m>>8)+24;return$"{h%24}:{(m+60)%60:D2}";}

Versión de 205 bytes

string f(string t,string u){Func<string,int>P=int.Parse;var T=t.Split(':');int s=u[3]<45?1:-1,m=P(T[1])+P(u.Substring(7))*s,h=P(T[0])+P($"{u[4]}"+u[5])*s+m/60+(m<0?-1:0)+24;return$"{h%24}:{(m+60)%60:D2}";}

Sin golf

string f(char[] t, char[] u)
{
    int s = ~(u[3]-45),
        z = 48,
        m = (t[3] - z) * 10 + t[4] - z + ((u[7] - z) * 10 + u[8] - z) * s,
        h = (t[0] - z) * 10 + t[1] - z + ((u[4] - z) * 10 + u[5] - z) * s + m / 60 + (m>>8) + 24;
    return $"{h % 24}:{(m + 60) % 60:D2}";
}

Original 214:

string f(string t,string u){Func<string,int>P=int.Parse;var T=t.Split(':');int h=P(T[0]),m=P(T[1]),s=u[3]<45?1:-1;m+=P(u.Substring(7))*s;h+=P($"{u[4]}"+u[5])*s+m/60+(m<0?-1:0)+24;return$"{h%24:D2}:{(m+60)%60:D2}";}

CJam , 40 bytes

r{':/60b}:F~r3>(\F\~1440,=60b{s2Te[}%':*

Pruébalo en línea! (Como un conjunto de pruebas).

Explicación

r           e# Read first input (time).
{':/60b}:F  e# Define a function F, which splits a string around ':' and
            e# treats the two elements as base-60 digits.
~           e# Run that function on the first input.
r3>         e# Read the second input and discard the 'UTC'.
(           e# Pull off the +-.
\F          e# Apply F to the timezone offset.
\~          e# Execute the + or - on the two amounts of minutes.
1440,=      e# Modulo 1440 to fit everything into the 24-hour format.
60b         e# Obtain base 60 digits again.
{s2Te[}%    e# Convert each digit to a string and pad it to 2 decimal digits.
':*         e# Join them with a ':'.

Retina , 100 bytes

:
59$*:,
+`(\d+):
$1,$1
\d+
$*
T`1`0`-.+
^
1440$*
+`10|\D

1{1440}

^(1{60})*(.*)
$#1:$.2
\b\d\b
0$&

Pruébalo en línea!

Explicación

:
59$*:,

Reemplaza cada uno :con 59 de ellos y una coma como separador.

+`(\d+):
$1,$1

Duplica repetidamente el número delante de a :. Entonces, las dos primeras etapas multiplican el valor de la hora por 60.

\d+
$*

Convierte cada número a unario.

T`1`0`-.+

Si hay un signo menos en la entrada, entonces esta etapa de transliteración convierte todos los 1s posteriores en 0s. Básicamente estamos usando 0como un -1dígito unario aquí.

^
1440$*

Inserte 1440 1s (es decir, un día completo). Esto es para asegurar que el tiempo no sea negativo.

+`10|\D

Esto elimina repetidamente todos los no dígitos (es decir, el espacio, el UTC, el +o -, así como todos los ,que hemos insertado) y la 10combinación, cancelando así los dígitos positivos y negativos. Básicamente, esto resta el segundo número del primero si es negativo, o lo agrega de otra manera.

1{1440}

Elimina 1440 1s si es posible (básicamente tomando el módulo de resultado 1440 para ajustarlo en solo 24 horas).

^(1{60})*(.*)
$#1:$.2

Descomponga el número en horas y minutos haciendo coincidir tantos fragmentos de 60 dígitos como sea posible (contando los fragmentos con $#1) seguidos de los dígitos restantes (cuya longitud se cuenta con $.2).

\b\d\b
0$&

Si hay un solo dígito en el resultado, anteponga un cero.