Herausforderung

Geben Sie die Zeit in dieser Zeitzone aus, wenn Sie eine Zeit und eine Zeitzone als Eingabe angegeben haben.

Zeit

Die Uhrzeit wird im 24-Stunden-Format wie folgt angegeben:

hh:mm

Dabei ist hh die zweistellige Stunde und mm die zweistellige Minute. Beachten Sie, dass Stunde und Minute immer mit Nullen wie folgt aufgefüllt werden:

06:09

Alle angegebenen Zeiten sind um UTC + 00: 00.

Die Stunden in Ihrer Ausgabe müssen nicht mit Nullen aufgefüllt werden, sondern Ihre Zeit muss im 24-Stunden-Format vorliegen

Zeitzone

Die Zeitzone wird im folgenden Format angegeben:

UTC±hh:mm

Wobei ± entweder ein + oder ein - ist und hh die zweistellige Stunde und mm die zweistellige Minute (diese werden wiederum mit Nullen aufgefüllt).

Um die Zeit in dieser Zeitzone zu ermitteln, müssen Sie entweder die Zeit nach UTC ± von der eingegebenen Zeit addieren (wenn das Symbol + ist) oder subtrahieren (wenn das Symbol - ist).

Wenn die Eingabe beispielsweise 24:56und wäre UTC-02:50, würden Sie 2 Stunden und 50 Minuten von 24:56 subtrahieren:

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

Die Ausgabe wäre 22:06.

Beispiele

Chicago

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

Kathmandu

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

Beachten Sie, dass dies zum vorherigen Tag gegangen ist.

Tokyo

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

Beachten Sie, dass dies bis zum folgenden Tag gegangen ist.

Regeln

Sie dürfen keine eingebauten Datumsfunktionen oder Bibliotheken verwenden.

Angenommen, alle Eingaben sind gültige Zeiten und Zeitversätze.

Die Zeitzone liegt im Bereich UTC-24:00bis UTC+24:00einschließlich.

Im Fall der halb Mitternacht sollte die korrekte Darstellung sein 00:30, nicht 24:30 .

Gewinnen

Der kürzeste Code in Bytes gewinnt.

APL (Dyalog APL) , 45 Bytes

Ausdruck

Nimmt zwei Zeichenketten als rechtes Argument.

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

Probieren Sie es online!

Erläuterung

24 60⊤die Zahl-zu-Basis- a ₂₄ b ₆₀ -Umwandlung

∘ von

⍎ die Evaluation

∘ von

⍕ die formatiert (dh mit Trennzeichen abgeflacht)

('+-'∩⍕) Schnittpunkt von "+ -" und formatierter Eingabe (dies extrahiert das Plus oder Minus)

, gefolgt von

(... )¨das Folgende für jeden der Eingänge (die Zeit und den Versatz)

 0 60⊥die a _∞ b _60- zu-Zahl-Umwandlung von

 2⊃ das zweite Element von

 ':'⎕VFIdie, Kolon als Feldtrennzeichen , V erified und F ixed I Nput von

 ¯5∘↑ die letzten fünf Zeichen ("hh: mm")

Schritt für Schritt zu "17:25" und "UTC + 09: 00"

Der linke Ausdruck auf der rechten Seite gibt die Daten der nächsten Zeile an.

                       '17: 25 '' UTC + 09: 00 '
                      / / \ \
(...) ¨ wendet den Funktionszug auf beide Eingänge an
                    / / \ \
¯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
                       \ \ / /
Hier hört ¨ auf, und die Ausführung wird in der Ergebnisliste fortgesetzt
                         \ \ / /
'/', 1045 540
('+ -' ∩⍕), '/' 1045 540
⍕ '+' '/' 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);}

Rufen Sie wie folgt auf:

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

JavaScript (ES6), 101 Byte

(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

Wäre 121 Bytes, wenn ich die Stunden auffüllen würde.

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`

Anrufen als 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

Alle Testfälle sind auf ideone

Das Ausgabeformat ist durch Leerzeichen ohne führende Nullen getrennt.

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

Aufgerufen als T ("12:00", "UTC + 02: 40")

Unglolfed für die Logik,

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

Jede Hilfe, um es unter 200 zu bekommen, wäre dankbar!

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}

Verwendung

f[gets,gets]

Eingänge (Beispiel)

08:50
UTC-06:00

Javascript (ES6), 93 bis 92 Bytes

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

Testfälle

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

Testfälle & ungolfed

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

    }
}

Rasuren

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

205-Byte-Version

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

Ungolfed

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[}%':*

Probieren Sie es online!(Als Testsuite.)

Erläuterung

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$&

Probieren Sie es online!

Erläuterung

:
59$*:,

Ersetzt jeweils :durch 59 und ein Komma als Trennzeichen.

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

Wiederholt die Nummer vor a :. Die ersten beiden Stufen multiplizieren also den Stundenwert mit 60.

\d+
$*

Wandle jede Zahl in eine unäre um.

T`1`0`-.+

Befindet sich ein Minuszeichen in der Eingabe, verwandelt diese Transliterationsstufe alle 1nachfolgenden s in 0s. Wir verwenden hier im Grunde genommen 0eine unäre -1Ziffer.

^
1440$*

Geben Sie 1440 1s ein (dh einen ganzen Tag). Dies soll sicherstellen, dass die Zeit nicht negativ wird.

+`10|\D

Dadurch werden wiederholt alle Nicht-Ziffern (dh das Leerzeichen, das UTC, das +oder -sowie alles, was ,wir eingefügt haben) und die 10Kombination entfernt, wodurch positive und negative Ziffern gelöscht werden. Dies subtrahiert im Grunde genommen die zweite Zahl von der ersten, wenn sie negativ ist, oder addiert sie auf andere Weise.

1{1440}

Entfernt 1nach Möglichkeit 1440 s (im Grunde genommen wird das Ergebnis modulo 1440 für eine 24-Stunden-Anpassung herangezogen).

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

Zerlegen Sie die Zahl in Stunden und Minuten, indem Sie so viele 60-stellige Blöcke wie möglich zuordnen (wobei die Blöcke mit gezählt werden $#1), gefolgt von den verbleibenden Ziffern (deren Länge mit gezählt wird $.2).

\b\d\b
0$&

Wenn das Ergebnis einzelne Ziffern enthält, stellen Sie eine Null voran.