Publié à l' origine (et supprimé) par @Tlink , qui était très probablement inspiré de cette question StackOverflow .
Comme c'était dommage, il a été supprimé, car cela semblait être un bon défi en général, j'ai pensé que je le publierais avec un formatage et des règles appropriés. (J'ai essayé de contacter @Tlink et d'obtenir son autorisation de le publier, mais il ne répond plus, c'est pourquoi j'ai décidé de le publier moi-même maintenant.)

Entrée: six chiffres.

Sortie: soit la première ou la dernière heure valide au format 24 heures ( 00:00:00jusqu'à 23:59:59). (Vous pouvez choisir vous-même si vous sortez la première ou la dernière fois valide.)

Exemple:

Lorsque les entrées le sont 1,8,3,2,6,4, les heures suivantes peuvent être créées:

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

Nous allons donc sortir soit 12:36:48ou 23:48:16dans ce cas, étant respectivement le premier / dernier.

Règles du défi:

• Indiquez si vous avez indiqué la première ou la dernière fois valide dans votre réponse.
• Les E / S sont flexibles. L'entrée peut être six entiers séparés; une chaîne contenant les six chiffres; une liste / un tableau d'entiers; un seul numéro (éventuellement octal); etc. La sortie peut être une liste / un tableau de chiffres correctement ordonné; une chaîne au format HH:mm:ss/ HHmmss/ HH mm ss; chaque chiffre imprimé avec un délimiteur de nouvelle ligne; etc. Votre appel.
• Vous êtes autorisé à prendre les chiffres dans l'ordre que vous souhaitez, afin qu'ils puissent déjà être triés du plus bas au plus élevé ou vice-versa.
• Si aucune heure valide ne peut être créée avec les chiffres donnés (c'est-à-dire 2,5,5,5,5,5), indiquez-le clairement de la manière que vous souhaitez. Peut retourner null/ false; "Not possible"; planter avec une erreur; etc. (Vous ne pouvez pas sortir une heure non valide comme 55:55:52ou une autre heure valide comme 00:00:00.) Veuillez indiquer comment il gère les entrées pour lesquelles aucune heure valide ne peut être créée.
• Vous n'êtes pas autorisé à afficher toutes les heures valides possibles. Seuls les premiers / derniers doivent être sortis / retournés.
• 24pendant des heures (ie 24:00:00), ou 60pour des minutes / secondes (ie 00:60:60) ne sont pas valides. Les plages sont [00-23]pour les heures et [00-59]pour les minutes et les secondes.

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, fonctions / méthode avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Veuillez également ajouter une explication si nécessaire.

Cas de test:

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 octets

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;}}

Essayez-le en ligne!

-12 octets grâce à Kevin Cruijssen

Probablement pas optimal, mais cela fonctionne. Curieusement, pour une raison quelconque, avec 7 arguments, l'implémentation de gcc sur TIO nécessite que vous les fournissiez réellement ou qu'il segfaults. Sur ma machine, cela n'est cependant pas nécessaire.

Format: G (X, 0,6) -> Y où X est le nombre à 6 chiffres dont les chiffres doivent être utilisés et Y est le nombre à 6 chiffres qui, pris comme un temps (en insérant: de manière appropriée), est minimal.

Haskell , 114 96 86 octets

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

Maintenant avec une sortie moins stricte. Prend l'entrée sous la forme d'une chaîne de chiffres et compare les permutations aux limites avec la comparaison de liste. Avec les minutes et les secondes, seul le premier chiffre est vérifié. Se bloque et brûle si aucune permutation n'est une heure valide.

Essayez-le en ligne!

Python 2 , 131 115 112 109 105 88 octets

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

Essayez-le en ligne!

Les E / S sont des listes d'entiers

Lance une erreur si aucun temps n'est possible

Alternative:

Python 2 , 88 octets

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

Essayez-le en ligne!

Renvoie la dernière heure

Renvoie un tuple vide pour les heures non valides

Enregistré

• -21 octets, grâce aux ovs

05AB1E , 20 15 octets

Entrez sous forme de chaîne triée.
La sortie est la plus petite durée sous forme de chaîne.
En cas d'absence de solution, une liste vide est la sortie.

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

Essayez-le en ligne!

JavaScript (ES6), 93 89 88 octets

Attend un tableau de 6 chiffres, triés du plus bas au plus élevé. Renvoie la chaîne à 6 chiffres de la première fois valide ou falses'il n'existe aucune solution.

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

Essayez-le en ligne!

Commenté

Nous essayons récursivement toutes les permutations de l'entrée jusqu'à ce que nous trouvions celle qui réussit un test hybride utilisant à la fois l'arithmétique et une expression régulière.

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 octets

Prend l'entrée comme une chaîne de chiffres et sort la première fois valide; boucle indéfiniment s'il n'y a pas de temps valide.

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

Essayez-le

Avertissement: extrêmement lent - ajoutez *1000après la seconde Xpour accélérer quelque peu. Et n'oubliez pas qu'une entrée non valide créera une boucle infinie et peut planter votre navigateur.

Explication

                   :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?

Rétine , 77 74 69 65 62 octets

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

Essayez-le en ligne! Affiche l'heure la plus ancienne ou la chaîne vide si aucune heure n'est trouvée. Edit: sauvé 5 8 octets grâce à @TwiNight. Explication:

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

Générez toutes les permutations. Le :fonctionne à travers la chaîne au fur et à mesure que les permutations sont générées, se terminant au début.

O`

Triez les heures dans l'ordre.

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

Sortir la première fois valide.

Rouge , 157 124 octets

Merci à Kevin Cruijssen de m'avoir rappelé de lire les descriptions plus attentivement!

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]]]

Essayez-le en ligne!

Prend une chaîne triée en entrée. Retourne nones'il n'est pas possible de prendre le temps.

Explication:

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 octets

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

Essayez-le en ligne!

Arnauld a enregistré un octet. Merci!

Attend une liste comme ['1','2','3','4','6','8']dans l'ordre trié:

Vous êtes autorisé à prendre les chiffres dans l'ordre que vous souhaitez, afin qu'ils puissent déjà être triés du plus bas au plus élevé ou vice-versa.

Émet un entier comme 123648pour 12:36:48. J'espère que c'est acceptable.

Gelée , 15 octets

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

Essayez-le en ligne!

Publié après une demande. L'approche est la même que celle de l'autre réponse, mais cette réponse a été développée indépendamment.

Japt , 39 23 octets

Je suis sûr qu'il existe un moyen plus court de le faire, mais je voulais essayer d'utiliser des objets Date dans 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.

Prend l'entrée comme un tableau trié de nombres, renvoie la dernière heure valide ou une sortie vide s'il n'en existe pas.
Perdu 10 livres d' octets grâce à Shaggy .

Essayez-le ici .

Rubis , 68 67 62 56 55 octets

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

Essayez-le en ligne!

Entrée: tableau trié de chiffres (sous forme d'entiers).

Sortie: tableau de chiffres ou nilsi aucune solution trouvée

Gelée , 17 octets

^{Je suis presque certain que ce n'est pas l'approche la plus courte ... j'y reviendrai plus tard :)}

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

Essayez-le en ligne!

Wolfram Language (Mathematica) , 63 octets

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

Essayez-le en ligne!

Prend une liste triée de chiffres en entrée. Renvoie Missing[NotFound]les entrées non valides.

Explication

Permutations@#

Trouvez toutes les permutations de l'entrée. Étant donné que l'entrée est triée, il est garanti que toutes les heures valides sont en ordre croissant.

FirstCase[ ... ]

Trouvez la première liste qui correspond ...

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

Le premier élément, marqué a, est égal à 0, 1, ou 2, et étiqueter le deuxième, troisième et cinquième éléments b, cet drespectivement ...

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

... tel que a*bmoins de 10, et det cmoins de 6, avec d >= c.

L'astuce est que pour tous les nombres 00à 24, le produit des deux chiffres est au plus 9, et les possibles nombres invalides 25à 29(puisque nous forçons le premier chiffre à 0, 1 ou 2) ont le produit d'au moins 10.

Pyth , 37 octets

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

Suite de tests

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 avec -palF, 73 octets

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

Essayez-le en ligne!

Sort comme HHmmsset sort une ligne vierge pour les entrées invalides.

Chaque réponse que j'ai faite récemment a utilisé globing pour des permutations ... Bizarre!

Bash + GNU sed, 83 , 72 , 69 octets

• Accepte l'entrée comme 6 arguments distincts;
• Renvoie la première heure (si trouvée);
• Ne renvoie rien (sortie vide) s'il n'existe aucune combinaison valide.

seq 0 86399|sed "s/^/date +%T -ud@/e;h;`printf s/%d//\; $@`/\w/d;x;q"

Comment ça marche

Pré-générer toutes les chaînes de temps possibles, pour les horodatages dans la plage 0 à 86399, en utilisant la commande GNU-sed e (xecute) + date.

%seq 0 86399|sed "s/^/date +%T -ud@/e;h;"

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

Générez un sedscript avec 6 commandes de substitution séquentielles, pour chaque chiffre d'entrée.

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

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

Ensuite, appliquez des substitutions, supprimez toutes les lignes d'entrée qui ont au moins un chiffre à gauche, imprimez la première ligne correspondante (la chaîne de temps d'origine est extraite de l'espace d'attente avec 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

Tester

%./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

Essayez-le en ligne!

Kotlin , 396 391 389 octets

Je ne sais pas comment rendre cela plus petit. Je pense que c'est le double de ce qui est possible. Produit le plus tôt possible. Merci à Kevin pour 7 octets!

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]}"}()

Essayez-le en ligne!

MATL , 31 30 octets

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

Essayez-le en ligne!

L'entrée est de 6 entiers, la sortie est le minimum d'heures, de minutes et de secondes dans un tableau. Crashes pour les entrées où aucun temps n'est possible.

(-1 octet grâce à @Luis Mendo.)

Perl 6 , 43 octets

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

Essayez-le en ligne!

Attend un tableau d'entrée trié. Renvoie Nilune entrée non valide.

Stax , 15 octets

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

Exécuter et déboguer

Il faut une chaîne de chiffres triés pour la saisie. Il renvoie la première permutation qui satisfait quelques critères.

• lexicographiquement moins que "24"
• les trois paires de caractères sont lexicographiquement inférieures à "6"

Rétine , 58 47 octets

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

Essayez-le en ligne!

L'entrée est de 6 chiffres dans l'ordre trié. La sortie est de 6 chiffres représentant la première heure valide ou une chaîne vide si aucune heure valide n'existe.

EDIT: j'étais un idiot, -9 octets

Explication

Algorithme

Par souci de concision, définissons un chiffre bas comme 0-5 et un chiffre haut comme 6-9.

Commencez par réorganiser les chiffres de façon à ce que le «bas» ou le «haut» de chaque position soit correct. La disposition correcte, pour chaque nombre de chiffres élevés dans l'entrée:

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

Étant donné que tout réarrangement échouerait, la vérification finale de l'entrée a 4+ chiffres élevés, nous pouvons ignorer complètement ce cas.

Ensuite, triez les bas et les hauts individuellement. Combiner avec le réarrangement, cela donne la valeur la plus basse qui satisfait les contraintes des minutes et des secondes. Cela donne donc la première heure valide, s'il en existe une.

Enfin, vérifiez si nous avons du temps valide. Sinon, jetez la chaîne.

Programme

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

Correspond LHHet échange les deux premiers chiffres de ce (devient HLH), et répétez cela jusqu'à ce qu'il n'en LHHexiste plus . Cela donne la bonne disposition.

En fait, j'ai menti. Aucun tri n'est nécessaire car 1) l'échange ne se produit qu'entre des chiffres adjacents et uniquement entre un bas et un haut; et 2) l'entrée est triée. Ainsi, les bas et les hauts individuellement sont déjà triés.

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

Ne conserve la chaîne que si elle est valide