挑战

给定一个时间和一个时区作为输入，输出该时区中的时间。

时间

时间将以24小时格式给出，如下所示：

hh:mm

其中hh是两位数的小时，mm是两位数的分钟。请注意，小时和分钟总是用零填充，如下所示：

06:09

给定的所有时间均为UTC + 00：00。

输出中的小时数不必用零填充，但您的时间必须为24小时格式

时区

时区将以以下格式给出：

UTC±hh:mm

其中±将是+或--和hh，是两位数字的小时，mm是两位数字的分钟（同样，这些数字将用零填充）。

要查找该时区的时间，您可以从输入时间中加（如果符号为+）或减去（如果符号为-）UTC±之后的时间。

例如，如果输入为24:56和UTC-02:50，则从24:56减去2小时50分钟：

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

输出将是 22:06。

例子

芝加哥

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

加德满都

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

萨摩亚

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

夏威夷

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

请注意，这已经到了前一天。

东京

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

请注意，这已经进行到第二天。

规则

您不得使用任何内置的日期函数或库。

假设所有输入均为有效时间和时间偏移。

该时区将在范围内UTC-24:00，以UTC+24:00包容。

在午夜半的情况下，正确的表示应该是00:30，而不是 24:30。

获奖

以字节为单位的最短代码获胜。

APL（Dyalog APL），45 字节

表达

将两个字符串作为正确的参数。

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

在线尝试！

说明

24 60⊤底数a ₂₄ b ₆₀转换

∘ 的

⍎ 评估

∘ 的

⍕ 格式化的（即用空格隔开）

('+-'∩⍕) “ +-”与格式化输入的交集（这将提取正负）

, 其次是

(... )¨每个输入的以下内容（时间和偏移量）

 0 60⊥的一个_∞ b ₆₀的-to-数转换

 2⊃ 第二个要素

 ':'⎕VFI的，使用结肠作为字段分隔符，V erified和˚F ixed 我 NPUT的

 ¯5∘↑ 最后五个字符（“ hh：mm”）

分步介绍“ 17:25”和“ UTC + 09：00”

右侧数据的左侧表达式给出了下一行的数据。

                       '17：25''UTC + 09：00'
                      ///
（...）¨将功能序列应用于两个输入
                    ///
¯5∘↑'17：25''UTC + 09：00'
'：'⎕VFI'17：25''09：00' 
2⊃（1 1）（17 25）（1 1）（9 0）
060⊥17 25 9 0
                      1045 540
                       \ \ / /
这是¨停止的地方，执行继续在结果列表上
                         \ \ / /
'/'，1045 540
（'+-'∩⍕），'/'1045 540
⍕'+''/'1045 540
⍎'+ / 1045 540'
2460⊤1585
                              2 25

C，109位元组

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

调用如下：

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

JavaScript（ES6），101个字节

(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

如果我补时的话将是121个字节。

Python 2，129字节

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`

称为 T("02:45", "UTC-05:33")

Python 2，84个字节

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

所有测试用例都在ideone上

输出格式以空格分隔，没有前导零。

Java 201字节

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

称为T（“ 12:00”，“ UTC + 02：40”）

毫无逻辑

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

任何帮助使其低于200美元将不胜感激！

Ruby，95个字节

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}

用法

f[gets,gets]

输入（示例）

08:50
UTC-06:00

Javascript（ES6），93 92字节

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

测试用例

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

爪哇 156 150 149 147 142字节

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

测试用例

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

    }
}

刨花

• 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个字节

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字节版本

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

不打高尔夫球

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

原始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个字节

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

在线尝试！（作为测试套件。）

说明

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

视网膜，100字节

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

1{1440}

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

在线尝试！

说明

:
59$*:,

:将它们替换为59，并用逗号作为分隔符。

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

重复复制前面的数字:。因此，前两个阶段将小时值乘以60。

\d+
$*

将每个数字转换为一元。

T`1`0`-.+

如果输入中有减号，则该音译阶段会将其后的所有1s转换为0s。在这里，我们基本上将其0用作一元-1数字。

^
1440$*

插入1440 1秒（即一整天）。这是为了确保时间不会变成负数。

+`10|\D

这种反复删除所有非数字字符（即空格，UTC中，+或-，以及所有的,我们插入）和10组合，从而抵消正面和负面的数字。如果它为负数，则基本上从第一个数字中减去第二个数字，否则将其相加。

1{1440}

移除1440 1如果可能的话， s（基本上取1440为模的结果以使其适合单个24小时）。

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

通过匹配尽可能多的60位数字块将数字分解为小时和分钟（用 $#1），然后将剩余的数字（长度用计数$.2）。

\b\d\b
0$&

如果结果中有任何一位数字，请在前面加上零。