Défi

Étant donné une heure et un fuseau horaire en entrée, affichez l'heure dans ce fuseau horaire.

Temps

L'heure sera donnée au format 24 heures comme suit:

hh:mm

Où hh est l'heure à deux chiffres et mm est la minute à deux chiffres. Notez que l'heure et la minute seront toujours remplies de zéros comme ceci:

06:09

Toutes les heures indiquées sont à UTC + 00: 00.

Les heures dans votre sortie ne doivent pas être remplies avec des zéros mais votre temps doit être au format 24 heures

Fuseau horaire

Le fuseau horaire sera donné dans le format suivant:

UTC±hh:mm

Où ± va être soit un + ou un - et hh, est l'heure à deux chiffres et mm est la minute à deux chiffres (encore une fois, ceux-ci seront remplis de zéros).

Pour trouver l'heure dans ce fuseau horaire, vous ajoutez (si le symbole est +) ou soustrayez (si le symbole est -) l'heure après l'UTC ± de l'heure entrée.

Par exemple, si l'entrée était 24:56et UTC-02:50, vous soustraire 2 heures et 50 minutes de 24:56:

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

La sortie serait 22:06.

Exemples

Chicago

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

Katmandou

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

Samoa

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

Hawaii

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

Notez que cela est allé à la veille.

Tokyo

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

Notez que cela est allé au lendemain.

Règles

Vous ne devez utiliser aucune fonction ou bibliothèque de date intégrée.

Supposons que toutes les entrées seront des heures et décalages horaires valides.

Le fuseau horaire sera compris entre inclus UTC-24:00et UTC+24:00inclus.

Dans le cas de minuit et demi , la représentation correcte devrait être 00:30, non 24:30 .

Gagnant

Le code le plus court en octets gagne.

APL (Dyalog APL) , 45 octets

Expression

Prend deux chaînes comme argument de droite.

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

Essayez-le en ligne!

Explication

24 60⊤le nombre en base - une conversion ₂₄ b ₆₀

∘ de

⍎ l'évaluation

∘ de

⍕ le formaté (c'est-à-dire aplati avec des espaces de séparation)

('+-'∩⍕) intersection de "+ -" et de l'entrée formatée (ceci extrait le plus ou le moins)

, suivi par

(... )¨ce qui suit pour chacune des entrées (le temps et le décalage)

 0 60⊥l' a _∞ b ₆₀ conversion -À-nombre de

 2⊃ le deuxième élément de

 ':'⎕VFIla, en utilisant du côlon comme séparateur de champ, V erified et F ixe I Nput de

 ¯5∘↑ les cinq derniers caractères ("hh: mm")

Pas à pas sur "17:25" et "UTC + 09: 00"

L'expression de gauche sur les données de droite donne les données de la ligne suivante.

                       '17: 25 '' UTC + 09: 00 '
                      / / \ \
(...) ¨ applique le train de fonctions aux deux entrées
                    / / \ \
¯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
                       \ \ / /
C'est là que ¨ s'arrête et l'exécution continue sur la liste résultante
                         \ \ / /
'/', 1045 540
('+ -' ∩⍕), '/' 1045 540
⍕ '+' '/' 1045 540
⍎ '+ / 1045 540'
24 60⊤ 1585
                              2 25

C, 109 octets

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

Appelez comme suit:

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

JavaScript (ES6), 101 octets

(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

Serait de 121 octets si je remplissais les heures.

Python 2, 129 octets

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`

Appeler en tant que T("02:45", "UTC-05:33")

Python 2, 84 octets

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

Tous les cas de test sont à idéone

Le format de sortie est séparé par des espaces, sans zéros non significatifs.

Java 201 octets

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

Appelé T ("12:00", "UTC + 02: 40")

Unglolfed pour la logique,

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

Toute aide pour obtenir moins de 200 serait appréciée!

Rubis, 95 octets

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}

Usage

f[gets,gets]

Entrées (exemple)

08:50
UTC-06:00

Javascript (ES6), 93 92 octets

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

Cas de test

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 octets

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

Cas de test et non golfés

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

    }
}

Copeaux

• 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 octets

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

Version 205 octets

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

Non 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 octets

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

Essayez-le en ligne! (En tant que suite de tests.)

Explication

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 ':'.

Rétine , 100 octets

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

1{1440}

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

Essayez-le en ligne!

Explication

:
59$*:,

Remplace chacun :par 59 d'entre eux et une virgule comme séparateur.

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

Duplique à plusieurs reprises le nombre devant un :. Ainsi, les deux premières étapes multiplient la valeur horaire par 60.

\d+
$*

Convertissez chaque nombre en unaire.

T`1`0`-.+

S'il y a un signe moins dans l'entrée, alors cette étape de translittération transforme tous les 1s après en 0s. Nous utilisons essentiellement 0un -1chiffre unaire ici.

^
1440$*

Insérez 1440 1s (soit une journée complète). C'est pour s'assurer que le temps ne devienne pas négatif.

+`10|\D

Cela supprime à plusieurs reprises tous les non-chiffres (c'est-à-dire l'espace, le UTC, le +ou -, ainsi que tous ceux que ,nous avons insérés) et la 10combinaison, annulant ainsi les chiffres positifs et négatifs. Cela soustrait fondamentalement le deuxième nombre du premier s'il est négatif, ou l'ajoute autrement.

1{1440}

Supprime 1440 1s si possible (en prenant le résultat modulo 1440 pour l'adapter en 24 heures).

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

Décomposez le nombre en heures et minutes en faisant correspondre autant de morceaux de 60 chiffres que possible (en comptant les morceaux avec $#1) suivi des chiffres restants (dont la longueur est comptée avec $.2).

\b\d\b
0$&

S'il y a un seul chiffre dans le résultat, ajoutez un zéro.