도전

시간과 시간대가 입력으로 주어지면 해당 시간대의 시간을 출력하십시오.

시각

시간은 다음과 같이 24 시간 형식으로 제공됩니다.

hh:mm

여기서 hh는 두 자리 시간이고 mm은 두 자리 분입니다. 시간과 분은 항상 다음과 같이 0으로 채워집니다.

06:09

주어진 모든 시간은 UTC + 00 : 00입니다.

출력 시간은 0으로 채워질 필요는 없지만 24 시간 형식이어야합니다.

시간대

시간대는 다음 형식으로 제공됩니다.

UTC±hh:mm

±가 + 또는 a-및 hh 일 경우, 두 자리 시간이고 mm은 두 자리 분입니다 (다시 말하면 0으로 채워짐).

해당 시간대에서 시간을 찾으려면 입력 한 시간에서 UTC ± 이후의 시간을 더하거나 (기호가 + 인 경우) 빼기 (기호가-인 경우)를 빼십시오.

예를 들어, 입력이 24:56and 인 경우 UTC-02:5024: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⊤수 - 투 -베이스 - ₂₄ B ₆₀ 변환

∘ 의

⍎ 평가

∘ 의

⍕ 형식화 됨 (즉, 공백으로 평평하게 됨)

('+-'∩⍕) "+-"와 형식화 된 입력의 교차점 (+ 또는-추출)

, 뒤에

(... )¨각 입력에 대한 다음 (시간 및 오프셋)

 0 60⊥_∞ B ₆₀ 의 -to-수 변환

 2⊃ 두 번째 요소

 ':'⎕VFI1, 필드 분리 결장을 사용하여 V는 erified 및 F는 ixed 난 의 nput

 ¯5∘↑ 마지막 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⊃ (11) (17 25) (11) (9 0)
0 60⊥ ​​17 25 9 0
                      1045 540
                       \ \ / /
여기서 ¨가 멈추고 결과 목록에서 실행이 계속됩니다.
                         \ \ / /
'/', 1045540
( '+-'∩⍕), '/'1045540
⍕ '+' '/'1045540
⍎ '+ / 1045540'
24 60⊤ 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"); }

자바 스크립트 (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 바이트가됩니다.

파이썬 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")

파이썬 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

모든 테스트 사례는 아이디어가 있습니다

출력 형식은 공백없이 구분되며 앞에 0이 없습니다.

자바 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 이하로 얻는 데 도움이 될 것입니다!

루비, 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

자바 스크립트 (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`-.+

입력에 빼기 부호가 있으면이 음역 단계는 입력 1후의 모든을 s로 바꿉니다 0. 우리는 기본적으로 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$&

결과에 단일 숫자가 있으면 0을 추가하십시오.