Tantangan

Diberi waktu dan zona waktu sebagai input, output waktu di zona waktu itu.

Waktu

Waktu akan diberikan dalam format 24 jam seperti:

hh:mm

Di mana jam adalah jam dua digit dan mm adalah menit dua digit. Perhatikan bahwa jam dan menit akan selalu diisi dengan nol seperti:

06:09

Semua waktu yang diberikan berada di UTC + 00: 00.

Jam dalam output Anda tidak harus diisi dengan nol tetapi waktu Anda harus dalam format 24 jam

Zona waktu

Zona waktu akan diberikan dalam format berikut:

UTC±hh:mm

Di mana ± akan menjadi + atau a - dan hh, adalah dua digit jam dan mm adalah dua digit menit (sekali lagi, ini akan diisi dengan nol).

Untuk menemukan waktu di zona waktu itu, Anda dapat menambahkan (jika simbolnya +) atau mengurangi (jika simbolnya adalah -) waktu setelah UTC ± dari waktu yang dimasukkan.

Misalnya, jika inputnya adalah 24:56dan UTC-02:50, Anda akan mengurangi 2 jam dan 50 menit dari 24:56:

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

Outputnya adalah 22:06.

Contohnya

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

Perhatikan bahwa ini sudah ke hari sebelumnya.

Tokyo

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

Perhatikan bahwa ini telah pergi ke hari berikutnya.

Aturan

Anda tidak boleh menggunakan fungsi tanggal atau pustaka bawaan apa pun.

Asumsikan semua input akan menjadi waktu dan offset waktu yang valid.

Zona waktu akan berada dalam kisaran UTC-24:00hingga UTC+24:00inklusif.

Dalam kasus setengah lewat tengah malam , representasi yang benar seharusnya 00:30, bukan 24:30 .

Kemenangan

Kode terpendek dalam byte menang.

APL (Dyalog APL) , 45 byte

Ekspresi

Membawa dua string sebagai argumen yang benar.

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

Cobalah online!

Penjelasan

24 60⊤konversi angka ke basis ₂₄ b ₆₀

∘ dari

⍎ evaluasi

∘ dari

⍕ yang diformat (yaitu diratakan dengan ruang pemisah)

('+-'∩⍕) persimpangan "+ -" dan input yang diformat (ini mengekstrak plus atau minus)

, diikuti oleh

(... )¨berikut ini untuk masing-masing input (waktu dan offset)

 0 60⊥yang a _∞ b ₆₀ konversi to-jumlah

 2⊃ elemen kedua dari

 ':'⎕VFIitu, menggunakan titik dua sebagai pemisah bidang, V erified dan F ixed I nput of

 ¯5∘↑ lima karakter terakhir ("jj: mm")

Selangkah demi selangkah pada "17:25" dan "UTC + 09: 00"

Ekspresi sisi kiri pada data sisi kanan, memberikan data pada baris berikutnya.

                       '17: 25 '' UTC + 09: 00 '
                      / / \ \
(...) ¨ menerapkan fungsi kereta ke kedua input
                    / / \ \
¯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
                       \ \ / /
Di sinilah ¨ berhenti, dan eksekusi berlanjut pada daftar yang dihasilkan
                         \ \ / /
'/', 1045 540
('+ -' ∩⍕), '/' 1045 540
⍕ '+' '/' 1045 540
⍎ '+ / 1045 540'
24 60⊤ 1585
                              2 25

C, 109 byte

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

Ajukan sebagai berikut:

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

Akan menjadi 121 byte jika saya mengisi waktu.

Python 2, 129 byte

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`

Sebut sebagai T("02:45", "UTC-05:33")

Python 2, 84 byte

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

Semua test case ada di ideone

Format output dipisahkan dengan ruang, tanpa nol di depan.

Java 201 byte

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

Disebut sebagai T ("12:00", "UTC + 02: 40")

Tidak terkurung karena logika,

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

Bantuan apa pun untuk mendapatkannya di bawah 200 akan dihargai!

Ruby, 95 byte

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}

Pemakaian

f[gets,gets]

Input (contoh)

08:50
UTC-06:00

Javascript (ES6), 93 92 byte

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

Uji kasus

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

Jawa 156 150 149 147 142 byte

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

Uji kasus & tidak diserang

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

    }
}

Serutan

• 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 205 byte

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

Tidak disatukan

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

Asli 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 byte

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

Cobalah online! (Sebagai suite uji.)

Penjelasan

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 byte

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

1{1440}

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

Cobalah online!

Penjelasan

:
59$*:,

Ganti masing :- masing dengan 59 dari mereka dan koma sebagai pemisah.

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

Gandakan berulang kali angka di depan a :. Jadi dua tahap pertama kalikan nilai jam dengan 60.

\d+
$*

Ubah setiap nomor menjadi unary.

T`1`0`-.+

Jika ada tanda minus pada input, maka tahap transliterasi ini mengubah semua 1setelahnya menjadi 0s. Kami pada dasarnya menggunakan 0sebagai -1angka unary di sini.

^
1440$*

Masukkan 1440 1s (yaitu sehari penuh). Ini untuk memastikan bahwa waktunya tidak menjadi negatif.

+`10|\D

Ini berulang kali menghilangkan semua non-digit (yaitu spasi, the UTC, +atau -, serta semua yang ,telah kami sisipkan) dan 10kombinasinya, sehingga membatalkan digit positif dan negatif. Ini pada dasarnya mengurangi angka kedua dari angka pertama jika negatif, atau menambahkannya sebaliknya.

1{1440}

Hapus 1440 1s jika memungkinkan (pada dasarnya mengambil modulo 1440 hasil agar sesuai menjadi 24 jam tunggal).

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

Uraikan angka menjadi beberapa jam dan menit dengan mencocokkan sebanyak mungkin potongan 60 digit (hitung dengan potongan $#1) diikuti oleh digit lainnya (yang panjangnya dihitung dengan $.2).

\b\d\b
0$&

Jika ada satu digit dalam hasil, tambahkan nol.