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:00hasta 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:48o 23:48:16en 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 volver null/ false; "Not possible"; chocar con un error; etc. (No puede generar una hora no válida como 55:55:52, u otra hora válida como 00: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.
• 24por horas (es decir 24:00:00), o 60por minutos / segundos (es decir 00: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

C (gcc) , 186 174 bytes

D[7]={0,1,10,100,1e3,1e4,1e5};G(O,L,F,T,I,M,E){if(!F)O=L<24e4&L%10000<6e3&L%100<60?L:1e9;else{for(T=1e9,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;O=T;}}

Prué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.

Haskell , 114 96 86 bytes

import Data.List
f l=minimum[x|x@[a,b,c,d,e,f]<-permutations l,a:[b]<"24",c<'6',e<'6']

Ahora 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!

Python 2 , 131 115 112 109 105 88 bytes

lambda s:min(d for d in permutations(s)if(2,4)>d[:2]>d[4]<6>d[2])
from itertools import*

Pruébalo en línea!

I / O son listas de enteros

Lanza un error si no hay tiempos posibles

Alternativa:

Python 2 , 88 bytes

lambda s:max(d*((2,4)>d[:2]>d[4]<6>d[2])for d in permutations(s))
from itertools import*

Pruébalo en línea!

Devuelve la última hora

Devuelve una tupla vacía para tiempos no válidos

Salvado

• -21 bytes, gracias a los ovs

05AB1E , 20 15 bytes

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

œʒ2ô•3Èñ•2ô‹P}н

Pruébalo en línea!

JavaScript (ES6), 93 89 88 bytes

Espera 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 falsesi no existe una solución.

f=(a,t='')=>t<24e4&/..([0-5].){2}/.test(t)?t:a.some((v,i)=>s=f(a.filter(_=>i--),t+v))&&s

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.

f = (                       // f = recursive function taking
  a, t = ''                 // a[] = input array and t = current time
) =>                        //
  t < 24e4 &                // if t is less than 240000
  /..([0-5].){2}/.test(t) ? // and it matches "hhMmSs" with M and S in [0-5]:
    t                       //   return t
  :                         // else:
    a.some((v, i) =>        //   for each digit v at position i in a[]:
      s = f(                //     save in s the result of a recursive call with:
        a.filter(_ => i--), //       a copy of a[] with the current digit removed
        t + v               //       the current digit appended to t
      )                     //     end of recursive call
    ) && s                  //   end of some(); if truthy, return s

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.

á
@øXr':}a@ÐX ¤¯8

Intentalo

Advertencia: Extremadamente lento: agregue *1000después del segundo Xpara acelerarlo un poco. Y no olvide que una entrada no válida creará un bucle infinito y puede bloquear su navegador.

Explicación

                   :Implicit input of string U
á                  :Get all permutations of U
\n                 :Reassign that array to U
      }a           :Loop until true and then return the argument that was passed
        @          :By default that argument is an integer X which increments on each loop so first we'll pass X through a function
         ÐX        :  new Date(X)
            ¤      :  Get the time
             ¯8    :  Slice to the 8th character to get rid of the timezone info
@                  :The function that tests for truthiness
  Xr':             :  Remove all colons in X
 ø                 :  Does U contain the resulting string?

Retina , 77 74 69 65 62 bytes

$
:
6+Lv$`(.)(.*):
$%`$2:$1$%'
O`
0L`([01].|2[0-3])([0-5].){2}

Pruébalo en línea! Emite la hora más temprana o la cadena vacía si no se puede encontrar la hora. Editar: Guardado 5 8 bytes gracias a @TwiNight. Explicación:

$
:
6+Lv$`(.)(.*):
$%`$2:$1$%'

Genera todas las permutaciones. El :trabaja su camino a través de la cadena como las permutaciones se generan, para terminar en la salida.

O`

Ordenar los tiempos en orden.

0L`([01].|2[0-3])([0-5].){2}

Salida del primer tiempo válido.

Rojo , 157124 bytes

¡Gracias a Kevin Cruijssen por recordarme que lea las descripciones con más cuidado!

func[s][a: 0:0:0 loop 86400[b: to-string a a: a + 1 if b/1 =#"0"[insert b"0"]if s = sort replace/all copy b":"""[return b]]]

Pruébalo en línea!

Toma una cadena ordenada como entrada. Devuelve nonesi no es posible hacer tiempo.

Explicación:

f: func[s][                                    ; the argument is a sorted string of digits
    a: 0:0:0                                   ; time object, set to 00:00:00 h 
    loop 86400 [                               ; loop through all seconds in 24 h
        b: to-string a                         ; convert the time to string 
        a: a + 1                               ; add 1 second to the current time   
        if b/1 = #"0" [                        ; prepend "0" if necessary
            insert b "0"                       ; (Red omits the leading 0)
        ]
        if s = sort replace/all copy b ":" ""[ ; compare the input with the sorted time
            return b                           ; return it if they are equal 
        ]
    ]
]

Python 2 , 78 bytes

lambda s:min(x for x in range(62**3)if x%100<60>x/100%100<s==sorted('%06d'%x))

Pruébalo en línea!

Arnauld salvó un byte. ¡Gracias!

Espera una lista como ['1','2','3','4','6','8']en orden ordenado:

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.

Emite un número entero como 123648para 12:36:48. Espero que sea aceptable.

Jalea , 15 bytes

Œ!s€2Ḍf«¥“ç;;‘Ṃ

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.

Japt , 39 23 bytes

Estoy bastante seguro de que hay una forma más corta de hacer esto, pero quería intentar usar objetos Date en Japt.

á ®¬ò q':Ãf@T<ÐXiSiKÅ
Ì

á                     // Get all permutations of the input array.
  ®¬ò q':à            // [1,2,3,4,5,6] -> "12:34:56"
          f@          // Filter the results, keeping those that
            T<        // are valid dates
              ÐXiSiKÅ // when made into a date object.
Ì                     // Return the last remaining item, if any.

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 de bytes gracias a Shaggy .

Probar aquí .

Ruby , 68 67 62 56 55 bytes

->*b{b.permutation.find{|a,b,c,d,e|c<6&&e<6&&a*9+b<22}}

Pruébalo en línea!

Entrada: matriz ordenada de dígitos (como enteros).

Salida: matriz de dígitos o nilsi no se encuentra una solución

Jalea , 17 bytes

^{Estoy casi seguro de que este no es el enfoque más corto ... veré esto nuevamente más tarde :)}

Œ!s2Ḍ<ẠʋÐṀ“ð<<‘ṢḢ

Pruébalo en línea!

Wolfram Language (Mathematica) , 63 bytes

FirstCase[Permutations@#,{a:0|1|2,b_,c_,_,d_,_}/;a*b-4<6>d>=c]&

Pruébalo en línea!

Toma una lista ordenada de dígitos como entrada. Devoluciones Missing[NotFound]para entradas inválidas.

Explicación

Permutations@#

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.

FirstCase[ ... ]

Encuentra la primera lista que coincide ...

{a:0|1|2,b_,c_,_,d_,_}

El primer elemento, etiquetado a, es 0, 1, o 2, y etiquetar el segundo, tercero, y los elementos de quinto b, cyd respectivamente ...

... /;a*b-4<6>d>=c

... tal que a*bsea ​​inferior a 10, dyc sea ​​menor que 6, con d >= c.

El truco es que para todos los números 00a 24, el producto de los dos dígitos es como máximo de 9, y los posibles números no válidos 25a 29(ya que forzar el primer dígito para ser 0, 1, o 2) El producto de menos 10.

Pyth , 37 bytes

j\:hf&&<shT24<s@T1 60<seT60mcs`Md2S.p

Banco de pruebas

j\:hf&&<shT24<s@T1 60<seT60mcs`Md2S.pQ # Code with implicit variables
   h                                   # The first element of
                                   .pQ # The list of all permutations of the input list
                                  S    # Sorted
                           mcs`Md2     # Mapped to three two digit long strings
    f                                  # Filtered on whether
       <shT24                          #  The first number is less than 24
      &      <s@T1 60                  #  AND the second number is less than 60
     &               <seT60            #  AND the third number is less than 60
j\:                                    # Joined by a colon

Perl 5 con -palF73 bytes

$"=",";($_)=grep@F~~[sort/./g]&/([01]\d|2[0-3])([0-5]\d){2}/,glob"{@F}"x6

Pruébalo en línea!

Muestra como HHmmssy muestra una línea en blanco para entradas no válidas.

Cada respuesta que he hecho recientemente ha utilizado globla permutaciones ... ¡Extraño!

Bash + GNU sed, 83 , 72 , 69 bytes

• Acepta entradas como 6 argumentos separados;
• Devuelve el tiempo más temprano (si se encuentra);
• No devuelve nada (salida vacía) si no existe una combinación válida.

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

00:00:00
00:00:01
...
23:59:59

Genere sedscript con 6 comandos de sustitución secuencial, para cada dígito de entrada.

%echo sed `printf s/%d//\; $@`

sed s/1//;s/2//;s/3//;s/4//;s/6//;s/8//;

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

%echo 23:45:12|sed 's/1//;s/2//;s/3//;s/4//;s/6//;s/8//;'
:5:2 //non-matching, delete

%echo 12:36:48|sed 's/1//;s/2//;s/3//;s/4//;s/6//;s/8//;'
:: //matching, print and stop

Prueba

%./timecomb 1 2 3 4 6 8
12:36:48
%./timecomb 2 5 5 5 5 5
%./timecomb 0 0 0 1 1 1
00:01:11
%./timecomb 1 1 2 2 3 3
11:22:33
%./timecomb 9 9 9 9 9 9
%./timecomb 2 3 5 5 9 9
23:59:59
%./timecomb 1 2 3 4 5 6
12:34:56
%./timecomb 0 0 0 0 0 0
00:00:00
%./timecomb 1 5 5 8 8 8
18:58:58
%./timecomb 1 5 5 5 8 8
15:58:58
%./timecomb 1 1 1 8 8 8
18:18:18

¡Pruébelo en línea!

Kotlin , 396 391 389 bytes

No 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!

fun p(d:Array<Int>)={val s=Array(6,{0})
val f=Array(6,{1>0})
val t=Array(3,{0})
val o=Array(3,{60})
fun r(i:Int){if(i>5){var l=0>1
var e=!l
for(p in 0..2){t[p]=s[p*2]*10+s[p*2+1]
l=l||(e&&t[p]<o[p])
e=e&&t[p]==o[p]}
if(t[0]<24&&t[1]<60&&t[2]<60&&l)for(p in 0..2)o[p]=t[p]}
else
for(p in 0..5)if(f[p]){f[p]=0>1
s[i]=d[p]
r(i+1)
f[p]=1>0}}
r(0)
if(o[0]>23)0
else "${o[0]}:${o[1]}:${o[2]}"}()

Pruébalo en línea!

MATL , 31 30 bytes

Y@3Xy[X1]X*!Y*t[4XX]6*<!AY)1Y)

Prué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.)

Perl 6 , 43 bytes

*.permutations.first:{24e4>.join&&6>.[2&4]}

Pruébalo en línea!

Espera una matriz de entrada ordenada. Devoluciones Nilpor entrada inválida.

Stax , 15 bytes

╝a╣=→aá≈#8(⌂≈58

Ejecutar y depurarlo

Se necesita una cadena de dígitos ordenados para la entrada. Devuelve la primera permutación que satisface algunos criterios.

• lexicográficamente menos de "24"
• los tres pares de caracteres son lexicográficamente menores que "6"

Retina , 58 47 bytes

+,V^2`[0-5][6-9]{2}
G`([01].|2[0-3])([0-5].){2}

Prué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:

# of highs  arrangment
0           LLLLLL
1           LLLLLH
2           LLLHLH
3           LHLHLH
4+          Not possible

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

+,V^2`[0-5][6-9]{2}

Coincide LHHy cambia los dos primeros dígitos en eso (se convierte HLH), y repita eso hasta que ya no LHHexista. 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.

G`([01].|2[0-3])[0-5].[0-5].

Solo mantiene la cadena si es un tiempo válido