El anagrama del tiempo

29

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 , 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
Kevin Cruijssen
fuente
1
¿No es 23:48:16una salida válida para el ejemplo?
TFeld
¿Debería mostrar solo una de las primeras / últimas horas o ambas?
tsh
@tsh Solo uno. Cuál depende de ti. Las dos respuestas de Python hasta la fecha son las primeras.
Kevin Cruijssen
¿Un "tiempo válido" no tiene en cuenta los segundos bisiestos? Por ejemplo, ¿ 06:08:60sería válido, dado que ha habido un segundo intercalar durante ese minuto?
Erik the Outgolfer
@EriktheOutgolfer No, 60para minutos y segundos no es válido. Los rangos son [00-23], [00-59]y [00-59]. Aclarará esto en el desafío.
Kevin Cruijssen

Respuestas:

9

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.

LambdaBeta
fuente
2
Creo que se puede jugar golf {0,1,10,100,1000,10000,100000}a {0,1,10,100,1e3,1e4,1e5}. Además, se puede jugar golf for(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];}a for(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 la if. Pruébelo en línea 174 bytes . Además, me gusta el G(O,L,F,T,I,M,E). :)
Kevin Cruijssen
Es curioso, usar mi máquina ...1e3,1e4,1e5}no funcionó. Gracias por la sugerencia.
LambdaBeta
Estás en todas partes con las respuestas de este chico, @ceilingcat, por cierto, un buen golf.
Zacharý
Agradezco la idea. Siempre es agradable ver que las personas realmente leen las respuestas y encuentran formas de mejorarlas. :) Estás en todas partes ahora también.
LambdaBeta
130 bytes
ceilingcat
6

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!

Angs
fuente
5

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
TFeld
fuente
5

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!

Emigna
fuente
5

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
Arnauld
fuente
5

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?
Lanudo
fuente
5

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.

Neil
fuente
Como puede generar dígitos separados por una nueva línea, puede guardar 5 bytes
TwiNight,
Incluso puede eliminar: en la etapa grep ya que debe coincidir con 6 caracteres y el primero debe ser 0, 1 o 2
TwiNight
@TwiNight Oh, si Grep es más corto que yo, puedo guardar 4 bytes más de todos modos.
Neil
Oh, sí, puedes simplementeL0
TwiNight
@TwiNight en 0Grealidad.
Neil
4

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 
        ]
    ]
]
Galen Ivanov
fuente
3
¿Es sortnecesario 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 "
Kevin Cruijssen
@Kevin Cruijssen - No, no es necesario en este caso. Actualizaré la solución para trabajar con entradas ordenadas. ¡Gracias!
Galen Ivanov
3

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.

Lynn
fuente
2
¿Podrías usar en 62**3lugar de 240000?
Arnauld
3

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

Liendre
fuente
25 bytes
Shaggy
@ Shaggy Gracias, muy ordenado. Hasta ahora, no sabía que Japt tenía una sección separada en los documentos de método para las fechas, lo cual me parece bastante tonto, solo intenté evitar que los tuviera.
Nit
3

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

GB
fuente
Puedes dejar el espacio en eval "creo.
Kevin Cruijssen
Sí, funciona, gracias.
GB
Creo que puedes hacerlo a*9+b<22por un byte.
JayCe
2

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!

Jonathan Allan
fuente
Tienes razón, este no es el enfoque más corto. Sin embargo, la humillación pública no es agradable, por lo que aún no comentaré las mejoras. :)
Erik the Outgolfer
El hecho de que se pueda suponer que la entrada está ordenada ahorra algo. ¡No es humillante ver mejor después de solo pasar 2 minutos en un campo de golf!
Jonathan Allan
Para ser más precisos, puedes hacerlo en 15 bytes; para guardar un byte, debes hacer algo trivial; para salvar al otro, no es tan trivial. Eso sí, iba a publicar esa versión de 15 bytes, pero utiliza su enfoque. Por cierto, ¿está bien tu salud?
Erik the Outgolfer
Sigue adelante y publica. ¡La salud está bien, estoy en el trabajo, así que no puedo pasar el tiempo jugando al golf!
Jonathan Allan
Al corriente. Ahora puedes ver por qué me refería a la "humillación". : P
Erik the Outgolfer
2

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.

JungHwan Min
fuente
2

Pyth , 37 bytes

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

Banco de pruebas

Explicación:
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
hakr14
fuente
2

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!

Dom Hastings
fuente
2

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!

zepelín
fuente
2

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!

JohnWells
fuente
2
No conozco a Kotlin, pero ¿realmente necesitas ambos var l=0>1y var e=1>0? Además, ¿por qué el l=ly e=enecesaria? Dos cosas que parecen funcionar al golf son var e=1>0a var e=!ly eliminando el espacio antes "None". Además, cualquier salida falsey está bien, por "None"lo que también puede ser justo 0.
Kevin Cruijssen
@ Kevin gracias por los 5 bytes. Sorprendido, me perdí uno de ellos. Como no estoy abortando el ciclo, no puedo ver de todos modos para evitar saber si las dos veces se han mantenido iguales para poder decidir que el nuevo es menor. Codifiqué un montón de formas y esto terminó más corto. Sin embargo, el código general es mucho más grande de lo que me gusta.
JohnWells
1
2 bytes más para jugar golf en su última versión: "0"puede ser solo0
Kevin Cruijssen
@Kevin que no será un tipo String y tendría que agregar: Any para permitir tanto String como Int.
JohnWells
1
Mmm, ok. Sin embargo, funciona en TIO y aún imprime 0sin 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.
Kevin Cruijssen
2

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

sundar - Restablece a Monica
fuente
Creo que puede reemplazar 2&Apor !A, porque la matriz binaria nunca será un vector de fila
Luis Mendo
1

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.

nwellnhof
fuente
1

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"
recursivo
fuente
1

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

TwiNight
fuente