오늘은 26 번째 윤초 가 발생하기 때문에 지금까지 발생한 GMT 또는 UTC로 윤초의 날짜와 시간을 출력해야합니다.

입력

입력이 없습니다.

산출

1972-06-30 23:59:60
1972-12-31 23:59:60
1973-12-31 23:59:60
1974-12-31 23:59:60
1975-12-31 23:59:60
1976-12-31 23:59:60
1977-12-31 23:59:60
1978-12-31 23:59:60
1979-12-31 23:59:60
1981-06-30 23:59:60
1982-06-30 23:59:60
1983-06-30 23:59:60
1985-06-30 23:59:60
1987-12-31 23:59:60
1989-12-31 23:59:60
1990-12-31 23:59:60
1992-06-30 23:59:60
1993-06-30 23:59:60
1994-06-30 23:59:60
1995-12-31 23:59:60
1997-06-30 23:59:60
1998-12-31 23:59:60
2005-12-31 23:59:60
2008-12-31 23:59:60
2012-06-30 23:59:60
2015-06-30 23:59:60

규칙

윤초를 허용하는 많은 내장 기능이 있는지 의심하기 때문에 허용 할 것입니다.

표준 허점은 허용되지 않습니다.

가장 짧은 코드가 승리합니다.

날짜 형식은 0으로 채워진 월과 4 자리 연도, 군사 시간 및 날짜와 시간을 구분하는 공백이 있어야합니다. UTC끝에 두는 것은 선택 사항입니다. 대시 또는 슬래시 선택

편집 : 네, 예상대로, 이것은 인코딩 도전이되었습니다. 인코딩만으로 윤초 문제를 해결할 수 있다면 ... 우리의 모든 코드가 훨씬 실용적입니다. 실용적으로 더 재미있는 도전에 대한 아이디어가 필요할까요?

CJam, 72 70 69 64 바이트

26,"~g¼K&Béx¸¦­Ø"240bFbf{<1b2md\1972+'-@6X$4*-'-Z3$" 23:59:60"N}

CJam 통역사 에서 온라인으로 사용해보십시오 .

생각

우리는 각 윤초를 2 * (Y-1972) + D 로 인코딩하여 시작합니다 . 여기서 D 는 12에서 발생하면 1 이고 그렇지 않으면 0 입니다.

모든 인코딩 된 윤초의 배열은 다음과 같습니다.

[0 1 3 5 7 9 11 13 15 18 20 22 26 31 35 37 40 42 44 47 50 53 67 73 80 86]

이 배열을 L 이라고합시다 .

배열은 오름차순이므로 실제 숫자 대신 연속적인 차이를 저장할 수 있습니다.

[1 2 2 2 2 2 2 2 3 2 2 4 5 4 2 3 2 2 3 3 3 14 6 7 6]

이 배열을 기본 15 자리의 숫자로 취급하면 정수를 얻습니다.

19238985373462115979359619336

기본 240의 숫자 (문자로 캐스트)

~g¼K&Béx¸¦­Ø

암호

26,             e# Push I := [0 ... 25].
"~g¼K&Béx¸¦­Ø"   e# Push the string from above.
240bFb          e# Convert from base 250 to base 15 to push L.
f{              e# For each J in I:
                e#   Push L.
  <             e#   Replace L with L[:J].
  1b            e#   Push the sum S of the integers in L[:J].
  2md           e#   Push (S / 2) and (S % 2).
  \1972+        e#   Add 1972 to (S / 2).
  '-@           e#   Push '-' and rotate (S % 2) on top.
  6X$4*-        e#   Compute (6 - 4 * (S % 2)).
  '-Z           e#   Push '-' and 3.
  3$            e#   Push a copy of (S % 2).
  " 23:59:60"   e#   Push that string.
  N             e#   Push a linefeed.
}

R, 78 75 바이트

내장되어 있습니까? 잘...

message(paste(as.Date(.leap.seconds)-1,"23:59:60\n"),"2015-06-30 23:59:60")

R에는 .leap.seconds시스템의 현지 시간으로 주어진 각 윤초 삽입 날짜와 시간이 포함 된 자동 변수 가 있습니다. R 버전 3.2.0부터는 오늘 포함되지 않으므로 수동으로 추가했습니다.

언 골프 + 설명 :

# Convert the datetime values to UTC dates. These will be a day past the
# expected output, so we can subtract 1 to get what we want.
dates <- as.Date(.leap.second) - 1

# Paste the UTC time and a newline onto the end of each date
datetimes <- paste(dates, "23:59:60\n")

# Print each time, including today, on its own line
message(datetimes, "2015-06-30 23:59:60")

당신은 할 수 있습니다 온라인으로보십시오 !

HTML, 594 바이트

1972-06-30 23:59:60<br>1972-12-31 23:59:60<br>1973-12-31 23:59:60<br>1974-12-31 23:59:60<br>1975-12-31 23:59:60<br>1976-12-31 23:59:60<br>1977-12-31 23:59:60<br>1978-12-31 23:59:60<br>1979-12-31 23:59:60<br>1981-06-30 23:59:60<br>1982-06-30 23:59:60<br>1983-06-30 23:59:60<br>1985-06-30 23:59:60<br>1987-12-31 23:59:60<br>1989-12-31 23:59:60<br>1990-12-31 23:59:60<br>1992-06-30 23:59:60<br>1993-06-30 23:59:60<br>1994-06-30 23:59:60<br>1995-12-31 23:59:60<br>1997-06-30 23:59:60<br>1998-12-31 23:59:60<br>2005-12-31 23:59:60<br>2008-12-31 23:59:60<br>2012-06-30 23:59:60<br>2015-06-30 23:59:60

¯ \ _ (ツ) _ / ¯

C, 160 146 141 140 바이트

처음 게시 할 때 "표준 허점"이 무엇인지 확실하지 않습니다. 물론 printf 경고가 있습니다.

160 바이트 :

원래 아이디어는 매년 2 비트 (6 월 및 12 월)를 사용하여 윤초를 인코딩하는 것입니다. 내부 while 루프는 인코딩을 한 번에 한 비트 씩 소비합니다. 128 비트 정수가 없으면 외부 while 루프가 필요합니다. 나머지는 모두 부기 및 수학입니다. :-)

int main(){long long X=0x2495288454AAAB,Y=1972,Z=1;while(Y<2000){while(X){if(X&1)printf("%d-%02d-%d 23:59:60\n",Y,6*(2-Z),31-Z);Y+=Z^=1;X>>=1;}X=0x104082000;}}

141 바이트 :

제안 된 팁을 적용하면 146 바이트로 줄어 듭니다. 그런 다음 외부 while 조건 (Y <2000에서 Z까지)을 단순화하여 141 바이트로 줄이는 방법을 찾았습니다. 그래서 트윗에 가깝습니다!

main(Z){long long X=0x2495288454AAAB,Y=1972;while(Z){while(X)X&1?printf("%d-%02d-%d 23:59:60\n",Y,12-6*Z,31-Z):1,Y+=Z^=1,X/=2;X=4362608640;}}

140 바이트 :

나는 그 날을 마이너스로 만들면 날짜의 대시가 제거 될 수 있음을 알았습니다. 6 월의 선행 0으로 인해 월과 함께 할 수 없습니다. 그러나 적어도 그것은 트윗에 들어갑니다!

main(Z){long long X=0x2495288454AAAB,Y=1972;while(Z){while(X)X&1?printf("%d-%02d%d 23:59:60\n",Y,12-6*Z,Z-31):1,Y+=Z^=1,X/=2;X=4362608640;}}

예쁜 버전 :

main(Z) {
    long long X = 0x2495288454AAAB, Y = 1972;
    while (Z) {
        while (X)
            X&1 ? printf("%d-%02d%d 23:59:60\n", Y, 12-6*Z, Z-31) : 1,
            Y += Z ^= 1,
            X /= 2;
        X = 4362608640;
    }
}

보너스 버전 :

하나의 64 비트 정수를 다른 것으로 비트 시프트하여 외부 루프를 제거했지만 "부호없는 long long"으로 인해 150 바이트입니다. "uint64"와 같은 것을 사용할 수 있다면 138 바이트입니다.

main(Z) {
    unsigned long long Y = 1972, X = 0x2495288454AAAB, W = 8520720;
    while (X)
        X&1 ? printf("%d-%02d-%d 23:59:60\n", Y, 12-6*Z, 31-Z) : 1,
        Y += Z^= 1,
        X = X/2 | (W>>=1)<<63;
}

파이썬 3, 91

Sp3000 의 인코딩 및 문자열 형식 을 사용 하지만 값을 마법의 숫자가 아닌 Python 3 바이트 객체 에 저장합니다 .

for n in b'()+-/1357:<>BGKMPRTWZ]kqx~':print('%d-%02d-3%d 23:59:60'%(1952+n/2,n%2*6+6,n%2))

인코딩에는 256 개의 가능한 바이트 값 중 86 개만 있으면되므로 인쇄 가능한 문자 범위를 사용하여 더보기 좋게 만듭니다.

브레인 포트, 806

++++++++[>++++++>+++++++>+++++++>++++++>++++++>++++++>+++++++>++++++>++++++>++++++>++++>++++++>++++++>+++++++>+++++++>+++++++>+++++++>+++++++>++++++>+<<<<<<<<<<<<<<<<<<<<-]>+>+>->++>--->>-->--->+++>>>++>+++>++>--->+>++>-->>++[<]>[.>]<[<]>>>>>>+>---->>>+[<]>[.>]<[<]>>>>+[<]>[.>]<[<]>>>>+[<]>[.>]<[<]>>>>+[<]>[.>]<[<]>>>>+[<]>[.>]<[<]>>>>+[<]>[.>]<[<]>>>>+[<]>[.>]<[<]>>>>+[<]>[.>]<[<]>>>+>-------->>->++++>>>-[<]>[.>]<[<]>>>>+[<]>[.>]<[<]>>>>+[<]>[.>]<[<]>>>>++[<]>[.>]<[<]>>>>++>>+>---->>>+[<]>[.>]<[<]>>>>++[<]>[.>]<[<]>>>+>---------[<]>[.>]<[<]>>>>++>>->++++>>>-[<]>[.>]<[<]>>>>+[<]>[.>]<[<]>>>>+[<]>[.>]<[<]>>>>+>>+>---->>>+[<]>[.>]<[<]>>>>++>>->++++>>>-[<]>[.>]<[<]>>>>+>>+>---->>>+[<]>[.>]<[<]>+>--------->--------->---[<]>[.>]<[<]>>>>+++[<]>[.>]<[<]>>>+>------>>->++++>>>-[<]>[.>]<[<]>>>>+++[<]>[.>]

이 온라인 통역사에서 실행할 수 있습니다 .

파이썬 2, 111104 바이트

n=0x6697f252225354422533333330;y=1972
while n:print'%d-%02d-3%d 23:59:60'%(y,n%2*6+6,n%2);y+=n/2%8;n/=16

기본 인코딩 및 더 많은 기본 인코딩.

GNU sed + 날짜 : 112

일반적인 Linux 배포판에는 윤초도 내장되어 있습니다. GNU sed와 날짜 사용하기 :

sed -n 's/^\([0-9]\+\).*/1899-12-31 \1sec/p' /usr/share/zoneinfo/leap-seconds.list|date -f- +"%Y-%m-%d 23:59:60"

GNU sed + 날짜 : 90

경로를 잘라서 몇 글자를 af 거리기 :

sed -n 's/^\([0-9]\+\).*/1899-12-31 \1sec/p' /u*/s*/z*/leap*|date -f- +'%Y-%m-%d 23:59:60'

Toby Speight에서 조정 한 GNU sed + date : 84

의견에서 제안 된 딥 골프 버전 :

sed -nr 's/^([0-9]+).*/date -d "1899-12-31 \1sec" "+%F 23:59:60"/ep' /u*/s*/z*/leap*

자바 스크립트 ( ES6 ) 125

``안의 줄 바꿈은 중요하고 계산됩니다.

테스트하려면 아래 스 니펫을 실행하십시오 (EcmaScript 6, Firefox 만 해당).

alert([..."09:;=DEFIX[01234567?ABGJQS"].map((c,i)=>c.charCodeAt()+1924+(i>10?'-12-31':'-06-30')+' 23:59:60').sort().join`
`)

PHP, 198 바이트

foreach([.5,1,2,3,4,5,6,7,8,9.5,10.5,11.5,13.5,16,18,19,20.5,21.5,22.5,24,25.5,27,34,37,40.5,43.5] as$d){$h=(int)$d-ceil($d);echo date("Y-m-d 23:59:60",mktime(0,0,0,-6*$h,31+$h,(int)$d+1972))."\n";}

불행히도 \n날짜 함수에 삽입 할 수 있는지 모르겠습니다 . 그렇다면이 때문에 3 바이트가 줄어 듭니다 ."".

8086 머신 코드 + DOS, 92 바이트

코드의 16 진 덤프 :

BE 3A 01 B1 57 D1 E0 75 03 AD EB F9 72 09 50 BA
47 01 B4 09 CD 21 58 BB 50 01 81 77 FC 01 04 80
37 01 80 3F 31 74 10 83 EB 05 4B FE 07 80 3F 3A
75 05 C6 07 30 EB F3 E2 CC C3 AA 2A 77 B5 6A DD
DF B6 BE FF 7D BF 31 39 37 32 2D 30 36 2D 33 30
20 32 33 3A 35 39 3A 36 30 0D 0A 24

실행하려면 92 바이트를 com-file에 쓰고 32 비트 Windows 또는 DOSBox에서 실행하십시오.

이 코드는 1 년 반마다 87 비트의 비트 맵을 사용합니다. 비트는 MSB에서 시작하여 16 개의 그룹으로 배열됩니다.

비트 맵 디코딩 :

                 ; when the program starts, ax=0 (tested on DOSBox)
myloop:
    shl ax, 1    ; shift the MSB left into the carry flag
    jnz mywork   ; if some bits are left in the register, work normally
    lodsw        ; if all bits were shifted out, load the next 16 bits
    jmp myloop   ; and check the MSB again

코드 구조로 인해 디코딩 중에 일부 비트가 손실되므로 반복해야했습니다. 어쨌든 87 비트를 96 비트로 채워야했기 때문에이 반복은 비트 맵을 팽창시키지 않습니다.

윤초를 인쇄 (또는 인쇄하지 않음) 한 후, 코드는 출력 메시지의 ASCII 코드를 조작하여 날짜를 반년 씩 증가시킵니다.

소스 코드 (로 조립 가능 tasm) :

    mov si, offset mydata
    mov cl, 57h ; number of iterations

myloop:
    shl ax, 1   ; shift the MSB left into the carry flag
    jnz mywork  ; if some bits are left in the register, work normally
    lodsw       ; if all bits were shifted out, load the next 16 bits
    jmp myloop  ; and check the MSB again
mywork:
    jc myinc_date ; shifted bit 1? - skip printing the message

    push ax
    mov dx, offset mymsg
    mov ah, 9
    int 21h     ; print the message
    pop ax

myinc_date:
    mov bx, offset mymsg + 9 ; pointer to the middle of the message
    xor word ptr [bx - 4], 401h ; change month 06<->12
    xor byte ptr [bx], 1 ; change day 30<->31
    cmp byte ptr [bx], '1'
    je myloop_end ; if 31 December, no need to increase the year
    sub bx, 5 ; pointer beyond the last digit of the year

myinc_year:
    dec bx
    inc byte ptr [bx] ; increase the digit
    cmp byte ptr [bx], '0' + 10
    jne myloop_end ; if the digit was less than 9, done
    mov byte ptr [bx], '0' ; set the digit to 0
    jmp myinc_year ; continue increasing other digits

myloop_end:
    loop myloop
    ret ; terminate the program

; In the following bitmap, the spaces before some LSBs
; show that the least significant 1-bit and all
; following 0-bits are lost during decoding.
mydata:
    dw 02aaah ; 00101010101010     10
    dw 0b577h ; 101101010111011    1
    dw 0dd6ah ; 11011101011010     10
    dw 0b6dfh ; 101101101101111    1
    dw 0ffbeh ; 11111111101111     10
    dw 0bf7dh ; 101111110111110    1

mymsg:
    db '1972-06-30 23:59:60',13,10,'$'

Pyth- 88 84 바이트

char로 변환하여 데이터를 압축하고 06-30vs 12-31데이터를 이진수로 저장합니다 .

jbm++-2047ed?"-06-30"hd"-12-31"" 23:59:60"C,j33678243 2CM"KKJIHGFEDBA@><:9765421*'# 

(끝에 공간이 있습니다)

온라인으로 사용해보십시오 .

파이썬 2 123 121 116 114 111

나는 그것을 꽤 짧게 얻었 지 만 그것이 얼마나 더 짧은 지 잘 모르겠습니다. 을 사용해 보았지만 exec서식이 너무 비쌉니다.

연결된 Wikipedia 페이지에서 테이블의 기본 16 인코딩을 사용했습니다.

편집 : 16 진수 인코딩 사용은 기본 36보다 짧습니다 (골프가 적은 버전 참조).

여기 사용해보십시오

n=0x410208002495288454aaab
for i in range(88):
    if n%2:print"%d-%02d-3%d 23:59:60"%(1972+i/2,i%2*6+6,i%2)
    n/=2

덜 골프 :

s=bin(int('WELD24ZDGIMBWWLFM',36))[2:]
for i in range(44):
    t,s=int(s[0]),s[1:]
    if t:print"%d-06-30 23:59:60"%(i+1972)
    t,s=int(s[0]),s[1:]
    if t:print"%d-12-31 23:59:60"%(i+1972)

C, 155 (149) 147 바이트

문자열과 실행 길이 인코딩을 사용하는 C의 또 다른 접근법이 있습니다. 다른 C 솔루션만큼 간결하지는 않지만 향상 될 수 있습니까?

155 바이트 :

문자열을 사용하여 월 / 일을 보유합니다.

main(Y){Y=1972;char*M="06-3012-31",*B="#@DGCDF7D3daTdS#!",b,c;while(b=*B++-33){c=b>>1&7;while(c--)printf("%d-%.5s 23:59:60\n",Y++,M+b%2*5);Y+=(b>>4&7)-1;}}

149 바이트 :

월 / 일 문자열을 제거합니다.

main(Y){Y=1972;char*B="#@DGCDF7D3daTdS#!",b,c;while(b=*B++-33){c=b>>1&7;while(c--)printf("%d-%02d-%d 23:59:60\n",Y++,6+b%2*6,30+b%2);Y+=(b>>4&7)-1;}}

147 바이트 :

연도 초기화를 제거합니다.

main(Y){char*B="#@DGCDF7D3daTdS#!",b,c;while(b=*B++-33){c=b>>1&7;while(c--)printf("%d-%02d-%d 23:59:60\n",1971+Y++,6+b%2*6,30+b%2);Y+=(b>>4&7)-1;}}

144 바이트 :

건너 뛰기 횟수가 실행 전 (후)에 적용되도록 버퍼를 다시 코딩하면 외부 while 루프의 문을 재정렬하고 쉼표 연산자를 사용하고 중괄호를 제거하여 2 바이트를 절약 할 수 있습니다.

다른 솔루션에서와 같이 하루를 음수로 만들어 다른 바이트를 절약 할 수 있습니다.

예쁜:

main(Y) {
    char *B = "#@DGCDF7D3daTdS#!", // buffer of bytes encoding runs
         b, // current byte
         c; // current count
    while (b = *B++-33) { // get byte
        c = b>>1&7; // get count
        while (c--) printf("%d-%02d-%d 23:59:60\n", 1971+Y++, 6+b%2*6, 30+b%2); // run
        Y += (b>>4&7)-1; // skip years
    }
}

설명:

실행은 바이트로 인코딩됩니다. 각 바이트에는 6 월 또는 12 월인지를 나타내는 1 비트, 길이 카운트의 경우 3 비트, 건너 뛰기 카운트의 경우 3 비트, 사용되지 않은 높은 비트 1이 있습니다.

건너 뛰기 횟수는 실행 후 건너 뛸 년 수입니다. 1972 년에 2 초의 윤초를 허용하기 위해 -1만큼 상쇄됩니다. 길이는 몇 년 동안 실행됩니까? 아마 +1 오프셋 될 수 있지만 현재는 아닙니다.

따라서 바이트는 다음 바이트로 이동하기 전에 "길이의 JUNE (또는 DECEMBER) 년 동안 윤초를 한 다음 SKIP-1 년을 건너 뛰십시오"를 의미합니다.

바이트는 33으로 오프셋되어 읽을 수있게하고 멋진 인코딩을 피합니다.

이는 1998-2005 년을 포괄 할만큼 충분한 건너 뛰기 비트가 있지만 ASCII 범위를 벗어 났으므로 추가 길이가 0이라는 것을 의미합니다. 또한 1972-1979 년 길이가 너무 길기 때문에 1979 년이 자체적으로 나타납니다.

바이트에 충분한 비트가 있으므로 이러한 문제는 궁극적으로 수정 될 수 있습니다.

q / kdb +, 95 94 93 바이트

asc 1_" "0:([]raze("DEFGHIJKSUV[^eh";"DMNOQXYZ]lo"){("d"$"m"$-12*95-6h$x)-y}'1 185;`23:59:60)

설명

매년 + 1 에 대해 1905 년 이후의 연도를 ASCII 문자로 인코딩하십시오. 예 :

1972 -> 1973 -> 68 -> D

6h$x로 "D"돌아갑니다 68. 이후 q의 날짜 시대입니다 2000.01.01, 우리는 빼기 95및 정수 - - 날짜 변환을 수행 "d"$"m"$-12*95-6h$x.

우리가 + 1 인 이유는 내년 초 부터 실제 연도의 12 월 31 일 또는 6 월 30 일 즉 1 일 또는 185 일 을 얻기 위해 일 수를 빼기 때문 입니다. 따라서 "DEFGHIJKSUV[^eh"12 월과 "DMNOQXYZ]lo"6 월의 윤년을 나타냅니다 . 페어링 - 뺄셈을 통해 이루어집니다 (a;b){x-y}'(c;d)경우, a및 b뺀 것이다 년이다 c와 d각각 일 수.

" "0:([]...)열 머리글이 생성 될 것이라는 작은 경고와 함께 올바른 형식을 제공하기 위해 결과를 준비합니다. 1_해당 헤더를 삭제 asc하고 주문을 올바르게 적용 합니다.

편집 : 100을 대신하여 95 년을 뺀 '재베이스'(1 문자 절약).

편집 2 : 정수에서 날짜로 변환 함수 내에서 피연산자의 위치를 ​​재정렬합니다.

파이썬 204 201

e,g,h=0,1972,0
for i in range(1,27):e,g,h={2:1,9:2,10:1,12:2,15:1,16:2,17:1,20:2,21:1,22:7,23:3,24:4,25:3}.get(i,e),g+e,(h,1-h)[i in[2,10,14,17,20,21,22,25]];print`g`+("-06-30","-12-31")[h]+" 23:59:60"

repl.it 에서 재생할 수 있습니다 .

편집 : 철저하게 구타! 압축 답변은 놀랍도록 짧습니다.

PHP, 164 바이트

foreach([.5,1,2,3,4,5,6,7,8,9.5,10.5,11.5,13.5,16,18,19,20.5,21.5,22.5,24,25.5,27,34,37,40.5,43.5]as$d){echo(ceil($d)+1971).($d%2?'-12-31':'-06-30')." 23:59:60\n";}

이것은 @Voitcus의 아이디어에 대한 약간의 수정입니다.

파이썬, 221 (217)

def d(x):
 q=x%10
 if x%2==0:
  p,r=q/2,"06-30"
 else:
  p,r=(q-1)/2,"12-31"
 return"%d%d-%s 23:59:60"%(p+197,x/10,r)
for x in [20,21,31,41,51,61,71,81,91,12,22,32,52,73,93,5,24,34,44,55,74,85,57,87,28,58]:print(d(x))

일부 통찰력

기본적으로 d(x)단일 2 자리 정수에서 3 개의 정수로 구성된 벡터를 압축 해제합니다. d(x)의 역함수 (26 윤초 날짜 시간 이상)로 구성되며 c(v), 이는 (1998,12,31)과 같은 3 상을 85와 같은 숫자로 바꾸는 압축 함수입니다. , 21 ... 28,58] 압축 기능이 도메인에 대해 형 용성이 있는지 확인하기 위해 다른 알고리즘을 설계했습니다. 즉, 다음 프로그램이 중복을 생성하지 않았는지 확인하고 출력을 위의 프로그램 목록으로 사용했습니다.

dates = [(1972,06,30),
    (1972,12,31),
    (1973,12,31),
    (1974,12,31),
    (1975,12,31),
    (1976,12,31),
    (1977,12,31),
    (1978,12,31),
    (1979,12,31),
    (1981,06,30),
    (1982,06,30),
    (1983,06,30),
    (1985,06,30),
    (1987,12,31),
    (1989,12,31),
    (1990,12,31),
    (1992,06,30),
    (1993,06,30),
    (1994,06,30),
    (1995,12,31),
    (1997,06,30),
    (1998,12,31),
    (2005,12,31),
    (2008,12,31),
    (2012,06,30),
    (2015,06,30)]

def c(v):
    x = (v[0] % 10) * 10
    x += v[2] % 30
    x += 2 * (int(v[0] / 10) - 197)
    return x

for v in dates:
    print(c(v))

압축 기능 c(v)은 매우 간단한 체계를 사용하여 bijective하도록 설계되었습니다. 예를 들어 보자 (1998,12,31).

• 식 (v [0] % 10) * 10은 연도의 단위 (예 : 1 9 9 8- > 8)를 선택하여 출력의 10 번째 자릿수 (현재 x = 80)로 만듭니다.
• 윤초의 두 번째 일이 발생하는 두 달의 일 조합 만 있으므로 06,30 사례와 12,31 사례를 구별하기 위해 day 구성 요소를 사용하기로 결정했습니다. 일이 30이면 표현식 v [2] % 30은 0이고, 날이 31이면 1입니다.이 예에서는 1을 x에 추가합니다 (따라서 x = 81).
• 마지막으로이 퍼즐은 50 년에 불과하다는 것을 알았습니다. 따라서 처음 10 년 (70 년대)을 0으로, 마지막 10 년 (2010 년대)을 4로 매핑하면 멋진 일을 할 수 있습니다. 보다 구체적으로, 0,1,2,3,4에 매핑하는 대신 0,2,4,6,8에 매핑하는 경우이 값을 x의 단위에 추가 할 수 있습니다. 이전 규칙으로 인해 0 또는 1. 결국 우리는이 마지막 단계로도 bijection을 망칠 수 없으며, 06,30 케이스의 단위는 0,2,4,6,8 중 하나이고 a의 단위는 12,31 건은 1,3,5,7,9 건 중 하나입니다. 그러므로 그 회귀는 분명하다. 이 예에서 1998 년은 30 년 (70 년대-> 0, 80 년대-> 1, 90 년대-> 2)이므로 2 * 2 = 4를 더합니다. 따라서 우리는 x = 85를 얻습니다.

이것이 사실인지 확인하기 위해 프로그램을 작성한 다음 d(x)의 역으로 정의 했습니다 c(v). 이 예에서 c ((1998,12,31))은 85이고 d (85)는 올바르게 인쇄합니다 1998-12-31 23:59:60.

gzip, 114 바이트

16 진 덤프 :

1f8b080853f9975502006c006dd04b0a80300c84e1bde01dbc40218fa6697aff8309e2a6fa6f3f86cc10adb426a3b95ce62b6a0d398f07d59aeb8e4ed80983701026e1242cc0a9307e1aa1130661599929327017911105393998079797917911105393998079791

위에서 설명한 바이트로 파일을 작성하십시오.

gunzip 또는 다른 압축 해제 프로그램을 사용하여 추출하여 "l"이라는 새 파일을 얻으십시오. 이 파일에는 원하는 출력이 포함되어 있습니다.