Desde hoy marca la ocasión del 26 segundo salto intermitente, su desafío será generar la fecha y hora de cada segundo intercalar en GMT o UTC que ha ocurrido hasta ahora, así como el que ocurra hoy.

Entrada

No hay entrada

Salida

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

Reglas

Como dudo que haya muchos elementos integrados que permiten segundos de salto, los permitiré.

Las lagunas estándar no están permitidas.

El código más corto gana.

El formato de fecha debe tener un mes con relleno de cero y un año de 4 dígitos, así como la hora militar y un espacio que separe la hora de la fecha. Poner UTCal final es opcional. Su elección de guiones o barras.

EDITAR: Sí, como se predijo, esto se convirtió en un desafío de codificación. Si solo la codificación pudiera solucionar el problema del segundo salto, ... entonces todo nuestro código sería mucho más práctico. ¿Quizás necesitamos algunas ideas para desafíos más divertidos con usos prácticos?

CJam, 72 70 69 64 bytes

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

Pruébelo en línea en el intérprete de CJam .

Idea

Comenzamos codificando cada segundo intercalar como 2 * (Y - 1972) + D , donde D es 1 si ocurre en diciembre y 0 en caso contrario.

La matriz de todos los segundos bisiestos codificados es:

[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 a llamar a esta matriz L .

Como la matriz está en orden ascendente, podemos almacenar las diferencias consecutivas en lugar de los números reales:

[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 los dígitos de un número base 15, obtenemos el entero

19238985373462115979359619336

qué dígitos en la base 240 (emitidos a los personajes) son

~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

¿Empotrados, dices? Bien...

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

R tiene una variable automática .leap.seconds que contiene la fecha y hora de cada inserción de segundo intercalar, dada en la hora local del sistema. A partir de la versión R 3.2.0, esto no incluye hoy, así que lo agregué manualmente.

Ungolfed + explicación:

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

¡Puedes probarlo en línea !

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

Publicación por primera vez, no estoy seguro de qué son las "lagunas estándar". Tengo advertencias printf, por supuesto.

160 bytes:

La idea original es codificar segundos intercalares usando dos bits por año: uno para junio y otro para diciembre. La codificación se consume un bit a la vez por el bucle while interno. Sin un entero de 128 bits, el bucle while externo es necesario. El resto es contabilidad y matemáticas. :-)

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:

La aplicación de los consejos sugeridos lo reduce a 146 bytes. Luego encontré una manera de simplificar la condición while externa (de Y <2000 a solo Z), reduciéndola a 141 bytes. ¡Tan cerca de un 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:

Noté que el guión en la fecha podría eliminarse haciendo que el día fuera negativo. No puedo hacerlo con el mes también debido al cero inicial en junio. ¡Pero al menos ahora cabe en un 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,Z-31):1,Y+=Z^=1,X/=2;X=4362608640;}}

Versión 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;
    }
}

Versión de bonificación:

Eliminé el bucle externo al cambiar un número entero de 64 bits a otro, pero es de 150 bytes, debido al bastante largo "sin signo largo largo"; si pudiera usar algo como "uint64" sería 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;
}

Pitón 3, 91

Utiliza la codificación y el formato de cadena de Sp3000 , pero almacena los valores en un objeto Python 3 bytes en lugar de un 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))

La codificación solo necesita 86 de los 256 valores posibles de un byte, por lo que se utiliza un rango de caracteres imprimibles para que se vea mejor.

Brainfuck, 806

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

Puede ejecutarlo en este intérprete en línea.

Python 2, 111104 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

Codificación base y más codificación base.

GNU sed + fecha: 112

Las distribuciones comunes de Linux también tienen incorporados los segundos bisiestos. Usando GNU sed y 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 + fecha: 90

Asegurando algunos personajes cortando el camino:

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

Fecha de GNU sed + ajustada por Toby Speight: 84

Versión profundamente golfizada propuesta en los comentarios:

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

JavaScript ( ES6 ) 125

La nueva línea dentro de `` es significativa y contada.

Para probar, ejecute el fragmento a continuación (siendo EcmaScript 6, solo 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";}

Desafortunadamente, no sé si puedo insertar \nen la función de fecha. Si es así, esto es 3 bytes menos debido a ."".

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

Hexdump del 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 ejecutar, escriba los 92 bytes en un com archivo y ejecútelo en Windows de 32 bits o DOSBox.

El código usa un mapa de bits con 87 bits, uno por medio año. Los bits se organizan en grupos de 16, comenzando desde MSB.

Decodificando el mapa de bits:

                 ; 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

Debido a la estructura del código, algunos bits se pierden durante la decodificación, así que tuve que repetirlos. Esta repetición no hincha el mapa de bits porque tuve que rellenar 87 bits a 96 bits de todos modos.

Después de imprimir (o no imprimir) el segundo intercalar, el código aumenta la fecha en medio año, utilizando manipulaciones en los códigos ASCII del mensaje de salida.

Código fuente (se puede ensamblar con 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 bytes

Convierte a char para comprimir los datos y guarda los datos 06-30versus 12-31como número binario.

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

(hay un espacio al final)

Pruébalo aquí en línea .

Python 2, 123 121 116 114 111

Logré hacerlo bastante corto, pero no estoy seguro de cuánto más corto puede ser. Traté de usarexec , pero el formato se vuelve demasiado costoso.

Utilicé una codificación de base 16 de la tabla desde la página de Wikipedia vinculada.

Editar: el uso de la codificación hexadecimal es más corto que la base 36 (ver la versión menos golfizada).

Pruébalo aquí

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

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

Aquí hay otro enfoque en C, usando cadenas y codificación de longitud de ejecución. No es tan breve como mi otra solución C, pero ¿tal vez se pueda mejorar?

155 bytes:

Usando una cadena para contener el mes / día.

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 la cadena mes / día.

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 la inicialización del año.

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:

Si volví a codificar el búfer para que el conteo de omisión se aplique antes (no después) de la ejecución, entonces podría reordenar las declaraciones en el bucle while externo, usar el operador de coma y eliminar las llaves, ahorrando 2 bytes.

Puedo guardar otro byte haciendo que el día sea negativo (como en mi otra solución).

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

Explicación:

Las ejecuciones están codificadas en bytes. Cada byte tiene un bit para indicar si es junio o diciembre, 3 bits para un recuento de longitud, 3 bits para un recuento de omisión y 1 bit alto no utilizado.

El recuento de omisión es el número de años que se omiten después de una carrera; está compensado por -1 para permitir dos segundos intercalares en 1972. La duración es cuántos años en una carrera; probablemente podría compensarse con +1 pero actualmente no lo es.

Por lo tanto, un byte significa: "Haga LONGITUD años de JUNIO (o DICIEMBRE) años de segundos bisiestos, luego omita SKIP-1 años" antes de pasar al siguiente byte.

Los bytes están compensados ​​por 33 para que sean legibles y evitar una codificación elegante.

Esto significa que aunque tenemos suficientes bits de omisión para cubrir 1998-2005, estamos fuera del rango ASCII, por lo que tenemos una carrera extra de longitud cero. Además, 1979 aparece solo porque la longitud 1972-1979 es demasiado larga.

Hay suficientes bits en los bytes, por lo que esos problemas pueden ser corregibles en última instancia.

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)

Explicación

Para cada año + 1 , codifique por años desde 1905 como un carácter ASCII, por ejemplo:

1972 -> 1973 -> 68 -> D

6h$xvueltas "D"atrás a 68. Como qla época de la fecha es 2000.01.01, restamos 95y realizamos la conversión de enteros a fecha "d"$"m"$-12*95-6h$x.

La razón por la que + 1 arriba es para restar el número de días desde el comienzo del próximo año para obtener el 31 de diciembre o el 30 de junio del año actual , es decir, 1 o 185 días. Por lo tanto, "DEFGHIJKSUV[^eh"representa los años con un segundo salto en diciembre, y "DMNOQXYZ]lo"para aquellos en junio. El emparejamiento-resta se realiza a través de (a;b){x-y}'(c;d), dónde ay bson años que se restarán por cy dnúmero de días respectivamente.

" "0:([]...)prepara los resultados para darnos el formato correcto, con una pequeña advertencia de que se generará un encabezado de columna. 1_suelta ese encabezado y finalmente aplica ascpara obtener el orden correcto.

editar : 're-base' para restar 95 años en lugar de 100 (guardar 1 personaje).

Edición 2 : reordena el posicionamiento de los operandos dentro de la función de conversión de enteros a la fecha.

Pitón, 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"

Puedes jugar con él en repl.it .

Editar: completamente golpeado! Las respuestas de compresión son sorprendentemente cortas.

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

Estas son solo algunas modificaciones en la idea 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))

Algunas ideas

Básicamente, d(x)descomprime un vector de 3 enteros de un solo entero de 2 dígitos. d(x)se construye como la función inversa (durante los 26 segundos bisiestos datetime) de c(v), que a su vez es una función de compresión que convierte un 3-uple como (1998,12,31) en un número como 85. Para derivar la lista [20 , 21 ... 28,58] Diseñé otro algoritmo para verificar que la función de compresión es biyectiva sobre el dominio. Es decir, me aseguré de que el siguiente programa no produzca duplicados, y usé su salida como la lista del programa anterior.

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

La función de compresión c(v)fue diseñada para ser biyectiva utilizando un esquema muy simple. Tomemos como ejemplo (1998,12,31).

• La expresión (v [0]% 10) * 10 selecciona las unidades del año (por ejemplo, 1 9 9 8 -> 8) y lo convierte en el décimo dígito de la salida (ahora x = 80).
• Solo hay una combinación de dos meses y días en la que sucede el segundo salto, así que decidí usar el componente de día para distinguir entre el caso 06,30 y el caso 12,31. La expresión v [2]% 30 es 0 si el día es 30 y es 1 si el día es 31. En nuestro ejemplo, sumamos 1 a x (por lo tanto, ahora x = 81).
• Finalmente, observé que este rompecabezas involucra solo 5 décadas; por lo tanto, si asigno la primera década (los años setenta) a 0 y la última década (los años 2010) a 4, puedo hacer cosas geniales. Más específicamente, si en lugar de mapear a 0,1,2,3,4 mapeo a 0,2,4,6,8 puedo agregar este valor a las unidades de x, que debido a la regla anterior es 0 o 1. Así que al final tenemos que también este último paso no atornilla la biyección, y obtenemos que las unidades de un caso 06,30 son una de 0,2,4,6,8 y que las unidades de un 12,31 caso son uno de 1,3,5,7,9. Por lo tanto, la biyección es obvia. En nuestro ejemplo, 1998 está en la tercera década (70s-> 0, 80s-> 1, 90s-> 2), por lo que agregamos 2 * 2 = 4. Entonces obtenemos x = 85.

Escribí el programa para verificar que esto es cierto, y luego lo definí d(x)como el inverso de c(v). En nuestro ejemplo, c ((1998,12,31)) es 85 yd (85) se imprime correctamente 1998-12-31 23:59:60.

gzip, 114 bytes

Hexdump:

1f8b080853f9975502006c006dd04b0a80300c84e1bde01dbc40218fa6697aff8309e2a6fa6f3f86cc10adb426a3b95ce62b6a0d398f07d59aeb8e4ed80983701026e1242cc0a9307e1aa11306615211b59710527b3961270cba9994fc7fc944829092faeedc313e7803993cfafb20020000

Cree un archivo con los bytes descritos anteriormente.

Extraiga usando gunzip u otro programa de descompresión para obtener un nuevo archivo llamado "l". Este archivo contiene el resultado deseado.