¡Salto por segundos de salto!

28

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?

mbomb007
fuente
¿Se requiere que la salida tenga esa distribución exacta, o puede tener cualquier distribución siempre que las 26 fechas estén allí?
Ismael Miguel
2
@IsmaelMiguel Deben estar en este orden.
mbomb007 01 de
Fuera del tema, pero mirando la lista, me pregunto por qué necesitamos menos segundos de salto en estos días que en el siglo anterior.
Sr. Lister el
@MrLister Vea el artículo vinculado de Wikipedia. Creo que tiene que ver con la velocidad de rotación cambiante de la Tierra.
mbomb007

Respuestas:

25

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.
}
Dennis
fuente
28
Esa sensación cuando tiene un dispositivo incorporado que resuelve casi por completo el problema y, sin embargo, la solución manual en CJam es más corta.
Alex A.
99
@AlexA. Hay algunas funciones integradas en Mathematica que puedo reimplementar en menos bytes en Mathematica .
Martin Ender
@ MartinBüttner: brutal.
Alex A.
35

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 !

Alex A.
fuente
si puede asignar "23:59:60" a una variable, puede guardar algunos caracteres
No es que Charles
1
@NotthatCharles: había pensado en eso, pero el método de R para combinar cadenas no es lo suficientemente conciso como para acortar la construcción de la fecha y la hora de hoy. Gracias por la entrada sin embargo!
Alex A.
24

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

¯ \ _ (ツ) _ / ¯

vijrox
fuente
66
@ Vioz: esta pregunta está etiquetada como complejidad kolmogorov, por lo que esta es una respuesta perfectamente legal. Aunque no es probable que gane ...
Digital Trauma
10
@mlepage Esa es una de las "lagunas estándar".
Jacob Raihle
44
@Voitcus guardar en archivo, abrir en un navegador. Es un workingcódigo html
edc65
99
@ AntonyD'Andrea Sí, ¿y qué? La valencia no se solicita en los code golfdesafíos.
edc65
55
@anatolyg NO eres divertido para [kolmogorov-complex]
vijrox
11

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;
}
mlepage
fuente
44
Bienvenido a PPCG. "Lagunas estándar" se refiere a esta publicación , pero en general solo significa "usar el sentido común y no hacer trampa". :)
Martin Ender
1
Creo que usar un forbucle ahorrará algunos bytes. Por cierto, int main()-> main(). Esto puede resultarle muy útil.
Spikatrix 01 de
Además: X>>=1es igual que X/=2, 6*(2-Z)es igual que 12-6*Z, y 4362608640es un byte más corto que 0x104082000. El intfrente de main()es innecesario, y si cambia main()a main(Z), puede eliminar la declaración Z=1.
aprensivo ossifrage
Muy buena solución, otra cosa para pensar: puede cambiar if(X&1)printf(...);con lo X&1?printf(...):1;que ahorra 1 byte
euanjt
y en lugar de while(X){...}usar comas para que pueda quitar las llaves, while(X)X&1?printf("%d-%02d-%d 23:59:60\n",Y,6*(2-Z),31-Z):1,Y+=Z^=1,X>>=1;ahorrando otros 2 bytes
euanjt
9

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.

xnor
fuente
7

Brainfuck, 806

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

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

Peter Olson
fuente
6

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.

Sp3000
fuente
5

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*
Jens Erat
fuente
Gracias por enseñarme dónde encontrar los datos de segundos intercalares. Desafortunadamente, mi date(GNU 8.23) los muestra como el primer segundo del siguiente minuto. ¿Qué estás usando que comprende el minuto de 60 segundos?
Toby Speight
Con coreutils GNU, lo tengo a 76, el afeitado bytes con la -rbandera, sustituyendo datecon el s///emodificador, y la sustitución %Y-%m-%dcon %Fen date: TZ = UTCsed -nr 's/^([0-9]+).*/date -d "1900-1-1 \1sec" "+%F %T"/ep' /u*/s*/z*/leap*
Toby Speight
Sabía que me perdí algo. Parece que no hay manera de especificar esto manualmente, al menos no peor que la mayoría de las otras soluciones. Veamos si a alguien se le ocurre alguna biblioteca de fechas para manipular adecuadamente los números que admiten esos segundos.
Jens Erat
Llegué allí usando 1899-12-31 \1secpara la fecha y codificando 23:59:60como la hora:sed -nr 's/^([0-9]+).*/date -d "1899-12-31 \1sec" "+%F 23:59:60"/ep' /u*/s*/z*/leap*
Toby Speight
3

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

edc65
fuente
2

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 ."".

Voitcus
fuente
Puede quitar ambos (int)y eliminar algunos espacios en blanco. La fecha arroja un error, si la zona horaria predeterminada no está configurada, silenciarla con un @. 187 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=$d-ceil($d);echo@date("Y-m-d 23:59:60",mktime(0,0,0,-6*$h,31+$h,$d+1972))."\n";}
Octfx
2

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,'$'
anatolyg
fuente
Me gustaría probar esto, pero parece que no puedo encontrar un solo editor en ningún lugar que le permita pegar hexadecimal y guardarlo en un archivo binario.
Sr. Lister el
@MrLister cualquier editor hexadecimal normal debería hacerlo por usted.
TheDoctor
1

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 .

Maltysen
fuente
1

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)
mbomb007
fuente
1

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.

mlepage
fuente
1

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.

hjk
fuente
1

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.

sudo rm -rf slash
fuente
Sorprendentemente, mi respuesta PHP es más corta, usando un algoritmo similar. Siempre he esperado que Python sea más compacto. ¿Quizás podrías jugar un poco más al golf?
Voitcus
Le daré un vistazo. Sin embargo, creo que la mejor ruta es la compresión, y otros ya lo han hecho
sudo rm -rf slash
0

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

pranzer
fuente
0

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.

damix911
fuente
1
Retirar q=x%10y reemplazar qcon en x%10todas partes. Es mas corto. También doy una descripción útil de algunos juegos de golf adicionales en su programa aquí . Recomiendo ver los consejos para jugar golf en la página de Python .
mbomb007 01 de
Este es el código de golf , por lo que debe intentar acortar la longitud de su código de cualquier manera posible.
mbomb007
-1

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.

Stef Heyenrath
fuente