Como hoje marca a ocasião do 26º segundo bissexto a ocorrer, seu desafio será produzir a data e a hora de cada segundo bissexto em GMT ou UTC que ocorreu até agora, bem como o que ocorre hoje.

Entrada

Não há entrada.

Saída

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

Regras

Como duvido que haja muitos recursos internos que permitam segundos bissextos, eu os permitirei.

As brechas padrão não são permitidas.

O menor código vence.

O formato da data deve ter um mês preenchido com zero e um ano com 4 dígitos, além de hora militar e um espaço que separa a hora da data. Colocar UTCno final é opcional. Sua escolha de traços ou barras.

EDIT: Sim, como previsto, isso se tornou um desafio de codificação. Se apenas a codificação pudesse resolver o problema do segundo salto, ... todo o nosso código seria muito mais prático. Talvez precisemos de algumas idéias para desafios mais divertidos com usos práticos?

CJam, 72 70 69 64 bytes

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

Experimente on-line no intérprete CJam .

Idéia

Começamos codificando cada segundo de salto como 2 * (Y - 1972) + D , onde D é 1 se ocorrer em dezembro e 0 em caso contrário.

A matriz de todos os segundos bissextos codificados é:

[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]

Vamos chamar essa matriz L .

Como a matriz está em ordem crescente, podemos armazenar as diferenças consecutivas em vez dos números reais:

[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]

Tratando esta matriz como os dígitos de um número base 15, obtemos o número inteiro

19238985373462115979359619336

quais dígitos na base 240 (convertidos para caracteres) são

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

Código

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 bytes

Built-ins, você diz? Bem...

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

R tem uma variável automática .leap.secondsque contém a data e a hora de cada inserção de segundo de salto, fornecida na hora local do sistema. A partir da versão 3.2.0 do R, isso não inclui hoje, então eu adicionei isso manualmente.

Ungolfed + explicação:

# 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")

Você pode experimentá-lo online !

HTML, 594 bytes

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 bytes

Primeira publicação, não tenho certeza do que são "brechas padrão". Tenho avisos de impressão, é claro.

160 bytes:

A idéia original é codificar segundos bissextos usando dois bits por ano: um para junho e outro para dezembro. A codificação é consumida um bit de cada vez pelo loop while interno. Sem um número inteiro de 128 bits, o loop while externo é necessário. O resto é tudo contabilidade e matemática. :-)

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 bytes:

A aplicação das dicas sugeridas reduz para 146 bytes. Encontrei uma maneira de simplificar a condição while externa (de Y <2000 a apenas Z), diminuindo-a para 141 bytes. Tão perto de um tweet!

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 bytes:

Percebi que o traço na data poderia ser eliminado, tornando o dia negativo. Não é possível fazê-lo com o mês também devido ao zero inicial em junho. Mas pelo menos ele se encaixa em um tweet agora!

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

Versão bonita:

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

Versão bônus:

Eu eliminei o loop externo deslocando um número inteiro de 64 bits para outro, mas são 150 bytes, devido ao bastante longo "não assinado muito longo"; se eu pudesse usar algo como "uint64", seria 138 bytes.

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

Python 3, 91

Usa a codificação e a formatação de string do Sp3000 , mas armazena os valores em um objeto Python de 3 bytes, em vez de um número mágico.

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

A codificação precisa apenas de 86 dos 256 valores possíveis de um bytes; portanto, é usado um intervalo de caracteres imprimíveis para torná-la mais agradável.

Brainfuck, 806

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

Você pode executá-lo neste intérprete online.

Python 2, 111 104 bytes

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

Codificação base e mais codificação base.

GNU sed + data: 112

As distribuições comuns do Linux também contam com os segundos bissextos. Usando GNU sed e date:

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 + data: 90

Protegendo alguns caracteres cortando o caminho:

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

GNU sed + date ajustado por Toby Speight: 84

Versão profundamente golfada proposta nos comentários:

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

JavaScript ( ES6 ) 125

A nova linha dentro `` é significativa e contada.

Para testar, execute o snippet abaixo (sendo EcmaScript 6, somente 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 bytes

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

Infelizmente, não sei se posso inserir \na função de data. Nesse caso, isso é 3 bytes a menos por causa de ."".

Código de máquina 8086 + DOS, 92 bytes

Hexdump do código:

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

Para executar, escreva os 92 bytes em um comarquivo -e execute no Windows ou no DOSBox de 32 bits.

O código usa um bitmap com 87 bits, um a cada meio ano. Os bits são organizados em grupos de 16, a partir de MSB.

Decodificando o bitmap:

                 ; 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

Por causa da estrutura do código, alguns bits são perdidos durante a decodificação, então tive que repeti-los. Essa repetição não incha o bitmap porque eu tive que preencher de 87 a 96 bits de qualquer maneira.

Após imprimir (ou não imprimir) o segundo bissexto, o código aumenta a data em meio ano, usando manipulações nos códigos ASCII da mensagem de saída.

Código fonte (pode ser montado com 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,'$'

Pitão - 88 bytes

Converte em char para compactar os dados e salva os dados 06-30versus 12-31como número binário.

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

(há um espaço lá no final)

Experimente aqui online .

Python 2, 123 121 116 114 111 111

Consegui reduzi-lo bastante, mas não sei quanto tempo ele pode ficar mais curto. Eu tentei usar exec, mas a formatação fica muito cara.

Eu usei uma codificação base 16 da tabela na página vinculada da Wikipedia.

Editar: o uso da codificação hexadecimal é menor que a base 36 (consulte a versão menos prática).

Experimente aqui

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

Menos golfe:

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 bytes

Aqui está outra abordagem em C, usando strings e codificação de comprimento de execução. Não é tão conciso quanto minha outra solução C, mas talvez possa ser melhorado?

155 bytes:

Usando uma string para armazenar o mês / dia.

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 bytes:

Eliminando a sequência de mês / dia.

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 bytes:

Eliminando a inicialização do ano.

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 bytes:

Se eu recodificasse o buffer para fazer com que a contagem de pulsos se aplicasse antes (e não depois) da execução, poderia reordenar as instruções no loop while externo, usar o operador de vírgula e eliminar os chavetas, economizando 2 bytes.

Posso salvar outro byte, tornando o dia negativo (como na minha outra solução).

Bonita:

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

Explicação:

As execuções são codificadas em bytes. Cada byte tem um bit para dizer se é junho ou dezembro, 3 bits para uma contagem de comprimento, 3 bits para uma contagem de ignorados e 1 bit alto não utilizado.

A contagem de pulos é o número de anos para pular depois de uma corrida; é compensado por -1 para permitir dois segundos bissextos em 1972. A duração é de quantos anos consecutivos; provavelmente pode ser compensado com +1, mas não está atualmente.

Portanto, um byte significa: "Faça LENGTH anos de JUNHO (ou DEZEMBRO) anos de pulo segundos e pule SKIP-1 anos" antes de passar para o próximo byte.

Os bytes são deslocados em 33 para torná-los legíveis e evitar codificação sofisticada.

Isso significa que, embora tenhamos pular bits suficientes para cobrir 1998-2005, estamos fora do intervalo ASCII, portanto, temos um comprimento extra de zero. Além disso, 1979 aparece por si só porque o comprimento 1972-1979 é muito longo.

Há bits suficientes nos bytes, portanto esses problemas podem ser corrigidos.

q / kdb +, 95 94 93 bytes

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

Explicação

Para cada ano + 1 , codifique para anos desde 1905 como um caractere ASCII, por exemplo:

1972 -> 1973 -> 68 -> D

6h$xvoltas "D"voltar para 68. Como qa época da data é 2000.01.01, subtraímos 95e executamos a conversão de números inteiros para data "d"$"m"$-12*95-6h$x.

A razão pela qual +1 foi acima é subtrair o número de dias a partir do início do próximo ano para obter o ano real de 31 de dezembro ou 30 de junho, ou seja, 1 ou 185 dias. Portanto, "DEFGHIJKSUV[^eh"representa os anos com um segundo de salto em dezembro e "DMNOQXYZ]lo"para os de junho. A subtração de emparelhamento é feita via (a;b){x-y}'(c;d), onde ae bsão os anos que serão subtraídos ce o dnúmero de dias, respectivamente.

" "0:([]...)prepara os resultados para fornecer a formatação correta, com uma pequena ressalva de que um cabeçalho da coluna será gerado. 1_larga esse cabeçalho e finalmente se aplica ascpara obter a ordem correta.

edit : 're-base' para subtrair 95 anos em vez de 100 (salvando 1 caractere).

edit 2 : reordenando o posicionamento dos operandos dentro da função de conversão de números inteiros até a data.

Python, 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"

Você pode jogar com ele em repl.it .

Edit: completamente derrotado! As respostas de compactação são incrivelmente curtas.

PHP, 164 bytes

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

Esta é apenas uma modificação da idéia de @ Voitcus

Python, 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))

Algumas idéias

Basicamente, d(x)descomprime um vetor de 3 números inteiros a partir de um único número inteiro de 2 dígitos. d(x)é construída como a função inversa (ao longo dos 26 segundos bissextos às vezes) de c(v), que por sua vez é uma função de compressão que transforma um triplo como (1998,12,31) em um número como 85. Para derivar a lista [20 , 21 ... 28,58] Eu projetei outro algoritmo para verificar se a função de compressão é bijetiva sobre o domínio. Ou seja, assegurei-me de que o programa a seguir não produz duplicatas e usei sua saída como a lista do programa acima.

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

A função de compactação c(v)foi projetada para ser bijetiva usando um esquema muito simples. Vamos tomar como exemplo (1998, 12, 31).

• A expressão (v [0]% 10) * 10 seleciona as unidades do ano (por exemplo, 1 9 9 8 -> 8) e o torna o décimo dígito da saída (agora x = 80).
• Há apenas uma combinação de dois meses / dia em que o segundo salto ocorre, então eu decidi usar o componente day para distinguir entre o caso 06,30 e o caso 12,31. A expressão v [2]% 30 é 0 se o dia for 30 e é 1 se o dia for 31. No nosso exemplo, adicionamos 1 a x (portanto, agora x = 81).
• Por fim, observei que esse quebra-cabeça envolve apenas 5 décadas; portanto, se eu mapear a primeira década (os anos setenta) para 0 e a última década (os anos 2010) para 4, eu posso fazer coisas legais. Mais especificamente, se em vez de mapear para 0,1,2,3,4 eu mapear para 0,2,4,6,8 eu posso adicionar esse valor às unidades de x, que devido à regra anterior é 0 ou 1. Então, no final, temos que também este último passo não estraga a bijeção, e entendemos que as unidades de uma caixa 06,30 são uma de 0,2,4,6,8 e que as unidades de uma 12,31 são um dos 1,3,5,7,9. Portanto, a bijeção é óbvia. Em nosso exemplo, 1998 está na terceira década (70s-> 0, 80s-> 1, 90s-> 2), então adicionamos 2 * 2 = 4. Então temos x = 85.

Eu escrevi o programa para verificar se isso é verdade e depois defini d(x)como o inverso de c(v). No nosso exemplo, c ((1998, 12, 31)) é 85 ed (85) é impresso corretamente 1998-12-31 23:59:60.

gzip, 114 bytes

Hexdump:

1f8b080853f9975502006c006dd04b0a80300c84e1bde01dbc40218fa6697aff8309e2a6fa6f3f86cc10adb426a3b95ce62b6a0d398f07d59aeb8e4ed80983701026e1242cc0a9307e1aa11306615211b59710527b3961270cba9994fc7fc944829092faeedc313e7803993cfafb20020000

Crie um arquivo com os bytes descritos acima.

Extraia usando o gunzip ou outro programa de descompressão para obter um novo arquivo chamado "l". Este arquivo contém a saída desejada.