Publicado originalmente (y eliminado) por @Tlink , que probablemente se inspiró en esta pregunta de StackOverflow .
Como era una lástima, se eliminó, porque en general parecía un buen desafío, pensé que lo volvería a publicar con el formato y las reglas adecuadas. (He intentado contactar a @Tlink y obtener su permiso para publicarlo, pero ya no responde, por eso decidí publicarlo yo mismo ahora).
Entrada: seis dígitos.
Salida: la primera o la última hora válida en el formato de 24 horas ( 00:00:00
hasta 23:59:59
). (Puede elegir usted mismo si genera la primera o la última hora válida).
Ejemplo:
Cuando las entradas son 1,8,3,2,6,4
, se pueden crear los siguientes tiempos:
12:36:48 12:38:46 12:46:38 12:48:36
13:26:48 13:28:46 13:46:28 13:48:26
14:26:38 14:28:36 14:36:28 14:38:26
16:23:48 16:24:38 16:28:34 16:28:43
16:32:48 16:34:28 16:38:24 16:38:42
16:42:38 16:43:28 16:48:23 16:48:32
18:23:46 18:24:36 18:26:34 18:26:43
18:32:46 18:34:26 18:36:24 18:36:42
18:42:36 18:43:26 18:46:23 18:46:32
21:36:48 21:38:46 21:46:38 21:48:36
23:16:48 23:48:16
Entonces sacaremos cualquiera de los dos, 12:36:48
o 23:48:16
en este caso, siendo el primero / último respectivamente.
Reglas de desafío:
- Indique si muestra la primera o la última hora válida en su respuesta.
- I / O es flexible. La entrada puede ser seis enteros separados; una cadena que contiene los seis dígitos; una lista / matriz de enteros; un solo número (posiblemente octal); etc. La salida puede ser una lista / matriz de dígitos correctamente ordenada; una cadena en el formato
HH:mm:ss
/HHmmss
/HH mm ss
; cada dígito impreso con delimitador de nueva línea; etc. Tu llamada. - Se le permite tomar los dígitos en el orden que desee, por lo que ya se pueden ordenar de menor a mayor o viceversa.
- Si no se puede crear un tiempo válido con los dígitos dados (es decir
2,5,5,5,5,5
), déjelo claro de la forma que desee. Puede volvernull
/false
;"Not possible"
; chocar con un error; etc. (No puede generar una hora no válida como55:55:52
, u otra hora válida como00:00:00
). Indique cómo maneja las entradas para las que no se puede crear una hora válida. - No tiene permiso para generar todos los tiempos válidos posibles. Solo el primero / último debe ser enviado / devuelto.
24
por horas (es decir24:00:00
), o60
por minutos / segundos (es decir00:60:60
) no son válidos. Los rangos son[00-23]
para horas y[00-59]
para minutos y segundos.
Reglas generales:
- Este es el código de golf , por lo que la respuesta más corta en bytes gana.
No permita que los lenguajes de code-golf lo desanimen a publicar respuestas con lenguajes que no sean codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación. - Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
- Las lagunas predeterminadas están prohibidas.
- Si es posible, agregue un enlace con una prueba para su código.
- Además, agregue una explicación si es necesario.
Casos de prueba:
Input: Earliest output: Latest output:
1,2,3,4,6,8 12:36:48 23:48:16
2,5,5,5,5,5 None possible None possible
0,0,0,1,1,1 00:01:11 11:10:00
1,1,2,2,3,3 11:22:33 23:32:11
9,9,9,9,9,9 None possible None possible
2,3,5,5,9,9 23:59:59 23:59:59
1,2,3,4,5,6 12:34:56 23:56:41
0,0,0,0,0,0 00:00:00 00:00:00
1,5,5,8,8,8 18:58:58 18:58:58
1,5,5,5,8,8 15:58:58 18:58:55
1,1,1,8,8,8 18:18:18 18:18:18
23:48:16
una salida válida para el ejemplo?06:08:60
sería válido, dado que ha habido un segundo intercalar durante ese minuto?60
para minutos y segundos no es válido. Los rangos son[00-23]
,[00-59]
y[00-59]
. Aclarará esto en el desafío.Respuestas:
C (gcc) ,
186174 bytesPruébalo en línea!
-12 bytes gracias a Kevin Cruijssen
Probablemente no sea óptimo, pero funciona. Curiosamente, por alguna razón, con 7 argumentos, la implementación de gcc en TIO requiere que realmente los suministre o que fallan. Sin embargo, en mi máquina eso es innecesario.
Formato: G (X, 0,6) -> Y donde X es el número de 6 dígitos cuyos dígitos se van a utilizar e Y es el número de 6 dígitos que, cuando se toma como un tiempo (al insertar: apropiadamente) es mínimo.
fuente
{0,1,10,100,1000,10000,100000}
a{0,1,10,100,1e3,1e4,1e5}
. Además, se puede jugar golffor(I=0;I<F;++I){E=O%10;M=G(O/10,L*10+E,F-1);T=T>M?M:T;O=(O/10)+E*D[F];}
afor(I=0;I++<F;M=G(O/10,L*10+E,F-1),T=T>M?M:T,O=(O/10)+E*D[F])E=O%10;
, y eliminar los corchetes alrededor de laif
. Pruébelo en línea 174 bytes . Además, me gusta elG(O,L,F,T,I,M,E)
. :)...1e3,1e4,1e5}
no funcionó. Gracias por la sugerencia.Haskell ,
1149686 bytesAhora con salida menos estricta. Toma datos como una cadena de dígitos y compara las permutaciones contra los límites con la comparación de listas. Con minutos y segundos solo se verifica el primer dígito. Se bloquea y se quema si no hay permutación en un momento válido.
Pruébalo en línea!
fuente
Python 2 ,
13111511210910588 bytesPruébalo en línea!
I / O son listas de enteros
Lanza un error si no hay tiempos posibles
Alternativa:
Python 2 , 88 bytes
Pruébalo en línea!
Devuelve la última hora
Devuelve una tupla vacía para tiempos no válidos
Salvado
fuente
05AB1E ,
2015 bytesEntrada como cadena ordenada.
La salida es el tiempo más pequeño como una cadena.
En caso de que no haya solución, la salida es una lista vacía.
Pruébalo en línea!
fuente
JavaScript (ES6),
938988 bytesEspera una matriz de 6 dígitos, ordenados de menor a mayor. Devuelve la cadena de 6 dígitos de la primera hora válida o
false
si no existe una solución.Pruébalo en línea!
Comentado
Intentamos recursivamente todas las permutaciones de la entrada hasta que encontremos una que pase una prueba híbrida utilizando aritmética y una expresión regular.
fuente
Japt , 17 bytes
Toma la entrada como una cadena de dígitos y genera la primera hora válida; bucles infinitos si no hay un tiempo válido.
Intentalo
Explicación
fuente
Retina ,
7774696562 bytesPruébalo en línea! Emite la hora más temprana o la cadena vacía si no se puede encontrar la hora. Editar: Guardado
58 bytes gracias a @TwiNight. Explicación:Genera todas las permutaciones. El
:
trabaja su camino a través de la cadena como las permutaciones se generan, para terminar en la salida.Ordenar los tiempos en orden.
Salida del primer tiempo válido.
fuente
L0
0G
realidad.Rojo ,
157124bytes¡Gracias a Kevin Cruijssen por recordarme que lea las descripciones con más cuidado!
Pruébalo en línea!
Toma una cadena ordenada como entrada. Devuelve
none
si no es posible hacer tiempo.Explicación:
fuente
sort
necesario al inicio? En el desafío, afirmo: " Se le permite tomar los dígitos en el orden que desee, por lo que ya pueden ordenarse de menor a mayor o viceversa "Python 2 , 78 bytes
Pruébalo en línea!
Arnauld salvó un byte. ¡Gracias!
Espera una lista como
['1','2','3','4','6','8']
en orden ordenado:Emite un número entero como
123648
para 12:36:48. Espero que sea aceptable.fuente
62**3
lugar de240000
?Jalea , 15 bytes
Pruébalo en línea!
Publicado después de una solicitud. El enfoque es el mismo que el de la otra respuesta, sin embargo, esta respuesta se desarrolló de forma independiente.
fuente
Japt ,
3923 bytesEstoy bastante seguro de que hay una forma más corta de hacer esto, pero quería intentar usar objetos Date en Japt.
Toma la entrada como un conjunto ordenado de números, devuelve el último tiempo válido o salida vacía si no existe ninguno.
Perdí 10
libras debytes gracias a Shaggy .Probar aquí .
fuente
Ruby ,
68 67 62 5655 bytesPruébalo en línea!
Entrada: matriz ordenada de dígitos (como enteros).
Salida: matriz de dígitos o
nil
si no se encuentra una soluciónfuente
eval "
creo.a*9+b<22
por un byte.Jalea , 17 bytes
Estoy casi seguro de que este no es el enfoque más corto ... veré esto nuevamente más tarde :)
Pruébalo en línea!
fuente
Wolfram Language (Mathematica) , 63 bytes
Pruébalo en línea!
Toma una lista ordenada de dígitos como entrada. Devoluciones
Missing[NotFound]
para entradas inválidas.Explicación
Encuentra todas las permutaciones de la entrada. Como la entrada está ordenada, se garantiza que todos los tiempos válidos están en orden creciente.
Encuentra la primera lista que coincide ...
El primer elemento, etiquetado
a
, es 0, 1, o 2, y etiquetar el segundo, tercero, y los elementos de quintob
,c
yd
respectivamente ...... tal que
a*b
sea inferior a 10,d
yc
sea menor que 6, cond >= c
.El truco es que para todos los números
00
a24
, el producto de los dos dígitos es como máximo de 9, y los posibles números no válidos25
a29
(ya que forzar el primer dígito para ser 0, 1, o 2) El producto de menos 10.fuente
Pyth , 37 bytes
Banco de pruebas
Explicación:fuente
Perl 5 con
-palF
73 bytesPruébalo en línea!
Muestra como
HHmmss
y muestra una línea en blanco para entradas no válidas.Cada respuesta que he hecho recientemente ha utilizado
glob
la permutaciones ... ¡Extraño!fuente
Bash + GNU sed,
83,72, 69 bytesseq 0 86399|sed "s/^/date +%T -ud@/e;h;`printf s/%d//\; $@`/\w/d;x;q"
Cómo funciona
Pregenere todas las cadenas de tiempo posibles, para las marcas de tiempo en el rango de 0 a 86399, utilizando el comando GNU-sed e (xecute) +
date
.%seq 0 86399|sed "s/^/date +%T -ud@/e;h;"
Genere
sed
script con 6 comandos de sustitución secuencial, para cada dígito de entrada.%echo sed `printf s/%d//\; $@`
Luego, aplique sustituciones, elimine las líneas de entrada que tengan al menos un dígito a la izquierda, imprima la primera línea coincidente (la cadena de tiempo original se extrae del espacio de espera con
x
).Prueba
¡Pruébelo en línea!
fuente
Kotlin ,
396391389 bytesNo tengo idea de cómo hacer esto más pequeño. Estoy pensando que es el doble de lo que es posible. Produce los primeros tiempos. ¡Gracias a Kevin por 7 bytes!
Pruébalo en línea!
fuente
var l=0>1
yvar e=1>0
? Además, ¿por qué ell=l
ye=e
necesaria? Dos cosas que parecen funcionar al golf sonvar e=1>0
avar e=!l
y eliminando el espacio antes"None"
. Además, cualquier salida falsey está bien, por"None"
lo que también puede ser justo0
."0"
puede ser solo0
0
sin errores. Y su función actual no especifica un tipo de retorno por lo que pude ver, así que ¿no volverá implícitamente como un objeto de todos modos? PD: No conozco a Kotlin en absoluto, solo lo intenté sin las comillas y los resultados fueron los mismos. ;) Tal vez algo más no funciona debido a eso, de lo que no estoy al tanto.MATL ,
3130 bytesPruébalo en línea!
La entrada es de 6 enteros, la salida es la hora, minutos y segundos mínimos en una matriz. Se bloquea para entradas donde no es posible ese tiempo.
(-1 byte gracias a @Luis Mendo.)
fuente
2&A
por!A
, porque la matriz binaria nunca será un vector de filaPerl 6 , 43 bytes
Pruébalo en línea!
Espera una matriz de entrada ordenada. Devoluciones
Nil
por entrada inválida.fuente
Stax , 15 bytes
Ejecutar y depurarlo
Se necesita una cadena de dígitos ordenados para la entrada. Devuelve la primera permutación que satisface algunos criterios.
fuente
Retina ,
5847 bytesPruébalo en línea!
La entrada es de 6 dígitos en orden ordenado. La salida es de 6 dígitos que representan la primera hora válida, o una cadena vacía si no existe una hora válida.
EDITAR: yo era un idiota, -9 bytes
Explicación
Algoritmo
Por brevedad, definamos un dígito bajo como 0-5, y un dígito alto como 6-9.
Primero, reorganice los dígitos para que el "bajo" o "alto" de cada posición sea correcto. La disposición correcta, para cada número de dígitos altos en la entrada:
Dado que cualquier reorganización fallaría, la verificación final en la entrada tiene más de 4 dígitos altos, podemos ignorar ese caso por completo.
Luego, clasifique los bajos y los altos individualmente. Combine con la reorganización, esto proporciona el valor más bajo que satisface las restricciones de minutos y segundos. Entonces esto da el tiempo válido más temprano, si existe.
Finalmente, verifique si tenemos tiempo válido. Si no, deseche la cadena.
Programa
Coincide
LHH
y cambia los dos primeros dígitos en eso (se convierteHLH
), y repita eso hasta que ya noLHH
exista. Esto da la disposición correcta.En realidad, mentí. No es necesario ordenar porque 1) el intercambio solo ocurre entre dígitos adyacentes y solo entre un valor bajo y uno alto; y 2) la entrada está ordenada. Por lo tanto, los mínimos y los máximos individualmente ya están ordenados.
Solo mantiene la cadena si es un tiempo válido
fuente