Thử thách

Cho thời gian và múi giờ làm đầu vào, xuất thời gian trong múi giờ đó.

Thời gian

Thời gian sẽ được đưa ra trong định dạng 24 giờ như vậy:

hh:mm

Trong đó hh là hai chữ số giờ và mm là phút hai chữ số. Lưu ý rằng giờ và phút sẽ luôn được đệm bằng các số 0 như vậy:

06:09

Tất cả thời gian đã cho là tại UTC + 00: 00.

Số giờ trong đầu ra của bạn không phải được đệm trong các số 0 nhưng thời gian của bạn phải ở định dạng 24 giờ

Múi giờ

Múi giờ sẽ được cung cấp theo định dạng sau:

UTC±hh:mm

Trong đó ± sẽ là + hoặc a - và hh, là hai chữ số giờ và mm là hai chữ số phút (một lần nữa, chúng sẽ được đệm bằng số 0).

Để tìm thời gian trong múi giờ đó, bạn có thể thêm (nếu ký hiệu là +) hoặc trừ (nếu ký hiệu là -) thời gian sau UTC ± từ thời gian được nhập.

Ví dụ: nếu đầu vào là 24:56và UTC-02:50, bạn sẽ trừ 2 giờ và 50 phút kể từ 24:56:

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

Đầu ra sẽ là 22:06.

Ví dụ

Chicago

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

Thủ đô

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

Lưu ý rằng điều này đã đi đến ngày hôm trước.

Tokyo

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

Lưu ý rằng điều này đã đi đến ngày hôm sau.

Quy tắc

Bạn không được sử dụng bất kỳ chức năng hoặc thư viện được xây dựng trong ngày.

Giả sử tất cả đầu vào sẽ là thời gian và thời gian bù hợp lệ.

Các múi giờ sẽ nằm trong phạm vi UTC-24:00cho UTC+24:00toàn diện.

Trong trường hợp nửa đêm qua , đại diện chính xác nên 00:30, không 24:30 .

Chiến thắng

Mã ngắn nhất tính bằng byte thắng.

APL (Dyalog APL) , 45 byte

Biểu hiện

Có hai chuỗi là đối số đúng.

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

Hãy thử trực tuyến!

Giải trình

24 60⊤số-to-cơ sở- một ₂₄ b ₆₀ chuyển đổi

∘ của

⍎ đánh giá

∘ của

⍕ định dạng (nghĩa là làm phẳng với các khoảng cách)

('+-'∩⍕) giao điểm của "+ -" và đầu vào được định dạng (điều này trích xuất cộng hoặc trừ)

, theo dõi bởi

(... )¨sau đây cho mỗi đầu vào (thời gian và bù)

 0 60⊥các một _∞ b ₆₀ -to-số chuyển đổi

 2⊃ yếu tố thứ hai của

 ':'⎕VFI, sử dụng thư đại tràng như tách lĩnh vực, V erified và F ixed tôi nput của

 ¯5∘↑ năm ký tự cuối cùng ("hh: mm")

Từng bước trên "17:25" và "UTC + 09: 00"

Biểu thức bên trái trên dữ liệu bên phải, cung cấp dữ liệu của dòng tiếp theo.

                       '17: 25 '' UTC + 09: 00 '
                      / / \ \
(...) áp dụng chức năng đào tạo cho cả hai đầu vào
                    / / \ \
¯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
                       \ \ / /
Đây là nơi dừng lại và thực hiện tiếp tục trong danh sách kết quả
                         \ \ / /
'/', 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);}

Gọi như sau:

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

Sẽ là 121 byte nếu tôi đệm giờ.

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`

Gọi như 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

Tất cả các trường hợp thử nghiệm là ở ideone

Định dạng đầu ra được phân tách không gian, không có số 0 đứng đầu.

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

Được gọi là T ("12:00", "UTC + 02: 40")

Unglolfed cho logic,

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

Bất kỳ trợ giúp để có được nó dưới 200 sẽ được đánh giá cao!

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}

Sử dụng

f[gets,gets]

Đầu vào (ví dụ)

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

Các trường hợp thử nghiệm

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

Các trường hợp thử nghiệm

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

    }
}

Phoi bào

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

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

Phiên bản 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}";}

Ung dung

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

Bản gốc 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[}%':*

Hãy thử trực tuyến! (Là một bộ thử nghiệm.)

Giải trình

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

Võng mạc , 100 byte

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

1{1440}

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

Hãy thử trực tuyến!

Giải trình

:
59$*:,

Thay thế mỗi cái :với 59 cái và dấu phẩy làm dấu phân cách.

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

Lặp lại nhiều lần số trước a :. Vì vậy, hai giai đoạn đầu tiên nhân giá trị giờ với 60.

\d+
$*

Chuyển đổi từng số để unary.

T`1`0`-.+

Nếu có một dấu trừ trong đầu vào, thì giai đoạn chuyển ngữ này biến tất cả các 1s sau nó thành 0s. Về cơ bản chúng tôi đang sử dụng 0như một -1chữ số đơn nhất ở đây.

^
1440$*

Chèn 1440 1giây (tức là cả ngày). Điều này là để đảm bảo rằng thời gian không bị âm.

+`10|\D

Điều này liên tục loại bỏ tất cả các chữ số không (tức là khoảng trắng, dấu UTC, +hoặc -, cũng như tất cả những gì ,chúng ta đã chèn) và 10kết hợp, do đó hủy bỏ các chữ số dương và âm. Điều này về cơ bản sẽ trừ số thứ hai từ số thứ nhất nếu nó âm hoặc thêm số khác.

1{1440}

Loại bỏ 1440 1giây nếu có thể (về cơ bản lấy modulo 1440 để phù hợp với nó trong 24 giờ).

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

Phân tách số thành giờ và phút bằng cách ghép càng nhiều khối 60 chữ số càng tốt (đếm các khối với $#1) theo sau là các chữ số còn lại (có độ dài được tính bằng $.2).

\b\d\b
0$&

Nếu có bất kỳ chữ số nào trong kết quả, hãy thêm số không.