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 UTC
al 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?
fuente
Respuestas:
CJam,
72706964 bytesPrué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:
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:
Tratando esta matriz como los dígitos de un número base 15, obtenemos el entero
qué dígitos en la base 240 (emitidos a los personajes) son
Código
fuente
R,
7875 bytes¿Empotrados, dices? Bien...
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:
¡Puedes probarlo en línea !
fuente
HTML, 594 bytes
¯ \ _ (ツ) _ / ¯
fuente
working
código htmlcode golf
desafíos.C,
160146141140 bytesPublicació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. :-)
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!
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!
Versión bonita:
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.
fuente
for
bucle ahorrará algunos bytes. Por cierto,int main()
->main()
. Esto puede resultarle muy útil.X>>=1
es igual queX/=2
,6*(2-Z)
es igual que12-6*Z
, y4362608640
es un byte más corto que0x104082000
. Elint
frente demain()
es innecesario, y si cambiamain()
amain(Z)
, puede eliminar la declaraciónZ=1
.if(X&1)printf(...);
con loX&1?printf(...):1;
que ahorra 1 bytewhile(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 bytesPitó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.
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.
fuente
Brainfuck, 806
Puede ejecutarlo en este intérprete en línea.
fuente
Python 2,
111104bytesCodificación base y más codificación base.
fuente
GNU sed + fecha: 112
Las distribuciones comunes de Linux también tienen incorporados los segundos bisiestos. Usando GNU sed y date:
GNU sed + fecha: 90
Asegurando algunos personajes cortando el camino:
Fecha de GNU sed + ajustada por Toby Speight: 84
Versión profundamente golfizada propuesta en los comentarios:
fuente
date
(GNU 8.23) los muestra como el primer segundo del siguiente minuto. ¿Qué estás usando que comprende el minuto de 60 segundos?-r
bandera, sustituyendodate
con els///e
modificador, y la sustitución%Y-%m-%d
con%F
endate
: TZ = UTCsed -nr 's/^([0-9]+).*/date -d "1900-1-1 \1sec" "+%F %T"/ep' /u*/s*/z*/leap*
1899-12-31 \1sec
para la fecha y codificando23:59:60
como la hora: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)
fuente
PHP, 198 bytes
Desafortunadamente, no sé si puedo insertar
\n
en la función de fecha. Si es así, esto es 3 bytes menos debido a.""
.fuente
(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";}
Código de máquina 8086 + DOS, 92 bytes
Hexdump del código:
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:
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
):fuente
Pyth -
8884 bytesConvierte a char para comprimir los datos y guarda los datos
06-30
versus12-31
como número binario.(hay un espacio al final)
Pruébalo aquí en línea .
fuente
Python 2,
123121116114111Logré hacerlo bastante corto, pero no estoy seguro de cuánto más corto puede ser. Traté de usar
exec
, 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í
Menos golfizado:
fuente
C,
155149147 bytesAquí 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.
149 bytes:
Eliminando la cadena mes / día.
147 bytes:
Eliminando la inicialización del año.
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:
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.
fuente
q / kdb +,
959493 bytesExplicación
Para cada año + 1 , codifique por años desde 1905 como un carácter ASCII, por ejemplo:
6h$x
vueltas"D"
atrás a68
. Comoq
la época de la fecha es2000.01.01
, restamos95
y 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óndea
yb
son años que se restarán porc
yd
nú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 aplicaasc
para 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.
fuente
Pitón,
204201Puedes jugar con él en repl.it .
Editar: completamente golpeado! Las respuestas de compresión son sorprendentemente cortas.
fuente
PHP, 164 bytes
Estas son solo algunas modificaciones en la idea de @ Voitcus
fuente
Python,
221217Algunas 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) dec(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.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).Escribí el programa para verificar que esto es cierto, y luego lo definí
d(x)
como el inverso dec(v)
. En nuestro ejemplo, c ((1998,12,31)) es 85 yd (85) se imprime correctamente1998-12-31 23:59:60
.fuente
q=x%10
y reemplazarq
con enx%10
todas 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 .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.
fuente