Originariamente pubblicato (ed eliminato) da @Tlink , molto probabilmente ispirato a questa domanda StackOverflow .
Dato che è stato un peccato, è stato cancellato, perché sembrava una buona sfida in generale, ho pensato di ripubblicarlo con una formattazione e regole adeguate. (Ho provato a contattare @Tlink e ottenere il suo permesso di pubblicarlo, ma non risponde più, motivo per cui ho deciso di pubblicarlo ora.)

Input: sei cifre.

Output: la prima o l'ultima ora valida nel formato 24 ore ( 00:00:00fino a 23:59:59). (Puoi scegliere tu stesso se hai emesso il primo o l'ultimo orario valido.)

Esempio:

Quando gli input sono 1,8,3,2,6,4, è possibile creare i seguenti orari:

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

Quindi usciremo uno 12:36:48o 23:48:16in questo caso, rispettivamente il primo / ultimo.

Regole della sfida:

• Indica se hai emesso la prima o l'ultima ora valida nella tua risposta.
• L'I / O è flessibile. L'input può essere sei numeri interi separati; una stringa contenente le sei cifre; una lista / matrice di numeri interi; un singolo numero (possibilmente ottale); ecc. L'output può essere un elenco / array di cifre correttamente ordinato; una stringa nel formato HH:mm:ss/ HHmmss/ HH mm ss; ogni cifra stampata con delimitatore di nuova riga; ecc. La tua chiamata.
• Puoi prendere le cifre nell'ordine che preferisci, quindi possono già essere ordinate dal più basso al più alto o viceversa.
• Se non è possibile creare un tempo valido con le cifre indicate (es. 2,5,5,5,5,5), Chiariscilo nel modo che desideri. Può restituire null/ false; "Not possible"; crash con un errore; ecc. (Non è possibile generare un tempo non valido come 55:55:52, o un altro tempo valido come 00:00:00.) Indicare come gestisce gli input per i quali non è possibile creare un tempo valido.
• Non è consentito produrre tutti i tempi validi validi. Solo il primo / l'ultimo deve essere emesso / restituito.
• 24per ore (es. 24:00:00) o 60per minuti / secondi (es. 00:60:60) non sono validi. Le gamme sono [00-23]per ore e [00-59]per minuti e secondi.

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si prega di aggiungere una spiegazione, se necessario.

Casi 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 byte

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

Provalo online!

-12 byte grazie a Kevin Cruijssen

Probabilmente non ottimale, ma funziona. Stranamente per qualche motivo con 7 argomenti l'implementazione di gcc su TIO richiede che tu li fornisca effettivamente o segfaults. Sulla mia macchina, tuttavia, non è necessario.

Formato: G (X, 0,6) -> Y dove X è il numero di 6 cifre le cui cifre devono essere utilizzate e Y è il numero di 6 cifre che, se preso nel tempo (inserendo: opportunamente) è minimo.

Haskell , 114 96 86 byte

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

Ora con output meno rigoroso. Prende l'input come una stringa di cifre e confronta le permutazioni con i limiti con il confronto delle liste. Con minuti e secondi viene controllata solo la prima cifra. Si schianta e brucia se nessuna permutazione è un tempo valido.

Provalo online!

Python 2 , 131 115 112 109 105 88 byte

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

Provalo online!

Gli I / O sono elenchi di numeri interi

Genera un errore se non sono possibili tempi

Alternativa:

Python 2 , 88 byte

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

Provalo online!

Restituisce l'ultima volta

Restituisce una tupla vuota per tempi non validi

Salvato

• -21 byte, grazie agli ovs

05AB1E , 20 15 byte

Immettere come stringa ordinata.
L'output è il tempo più piccolo come stringa.
In caso di mancata soluzione, viene visualizzato un elenco vuoto.

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

Provalo online!

JavaScript (ES6), 93 89 88 byte

Si aspetta una matrice di 6 cifre, ordinate dal più basso al più alto. Restituisce la stringa di 6 cifre della prima ora valida o falsese non esiste alcuna soluzione.

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

Provalo online!

Commentate

Proviamo in modo ricorsivo tutte le permutazioni dell'input fino a quando non ne troviamo uno che supera un test ibrido usando sia l'aritmetica che un'espressione regolare.

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 byte

Prende l'input come una stringa di cifre e genera la prima volta valida; scorre all'infinito se non c'è tempo valido.

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

Provalo

Avvertenza: estremamente lento: aggiungere *1000dopo il secondo Xper accelerare un po '. E non dimenticare che un input non valido creerà un loop infinito e potrebbe causare l'arresto anomalo del browser.

Spiegazione

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

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

Provalo online! Emette il primo tempo o la stringa vuota se non è possibile trovare il tempo. Modifica: salvato 5 8 byte grazie a @TwiNight. Spiegazione:

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

Genera tutte le permutazioni. Il :si sta facendo strada anche se la stringa come le permutazioni sono generati, fino a raggiungere la partenza.

O`

Ordina i tempi in ordine.

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

Emette il primo tempo valido.

Rosso , 157 124 byte

Grazie a Kevin Cruijssen per avermi ricordato di leggere più attentamente le descrizioni!

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

Provalo online!

Accetta una stringa ordinata come input. Restituisce nonese non è possibile guadagnare tempo.

Spiegazione:

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 byte

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

Provalo online!

Arnauld ha salvato un byte. Grazie!

Si aspetta un elenco come ['1','2','3','4','6','8']in ordine:

Puoi prendere le cifre nell'ordine che preferisci, quindi possono già essere ordinate dal più basso al più alto o viceversa.

Emette un numero intero come 123648per 12:36:48. Spero sia accettabile

Gelatina , 15 byte

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

Provalo online!

Inserito dopo una richiesta. L'approccio è uguale a quello dell'altra risposta, tuttavia questa risposta è stata sviluppata in modo indipendente.

Japt , 39 23 byte

Abbastanza sicuro che ci sia un modo più breve per farlo, ma volevo provare a usare gli oggetti Date in 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.

Accetta input come una matrice di numeri ordinati, restituisce l'ultimo tempo valido o output vuoto se non esiste.
Ha perso 10 chili grazie a Shaggy .

Provalo qui .

Rubino , 68 67 62 56 55 byte

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

Provalo online!

Input: ordinato matrice di cifre (come numeri interi).

Output: matrice di cifre o nilse non viene trovata alcuna soluzione

Gelatina , 17 byte

^{Sono quasi certo che questo non sia l'approccio più breve ... lo rivedremo più tardi :)}

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

Provalo online!

Wolfram Language (Mathematica) , 63 byte

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

Provalo online!

Prende un elenco ordinato di cifre come input. ritornaMissing[NotFound] per input non validi.

Spiegazione

Permutations@#

Trova tutte le permutazioni dell'input. Poiché l'input è ordinato, è garantito che tutti i tempi validi siano in ordine crescente.

FirstCase[ ... ]

Trova il primo elenco corrispondente a ...

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

Il primo elemento, etichetta a, è 0, 1 o 2, e l'etichetta della seconda, terza e quinta elementi b, ce drispettivamente ...

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

... tale che a*bè inferiore a 10, e de cinferiore a 6, con d >= c.

Il trucco è che per tutti i numeri 00a 24, il prodotto delle due cifre è al massimo 9, ed i possibili numeri validi 25a 29(poiché si forza la prima cifra a 0, 1 o 2) presentano il prodotto di almeno il 10.

Pyth , 37 byte

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

Suite di test

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 -palF, 73 byte

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

Provalo online!

Emette come HHmmsse genera una riga vuota per le voci non valide.

Ogni risposta che ho fatto di recente ha usato globing per permutazioni ... Strano!

Bash + GNU sed, 83 , 72 , 69 byte

• Accetta input come 6 argomenti separati;
• Restituisce il primo tempo (se trovato);
• Non restituisce nulla (output vuoto) se non esiste una combinazione valida.

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

Come funziona

Pre-generare tutte le possibili stringhe di tempo, per i timestamp nell'intervallo da 0 a 86399, usando il 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

Genera sedscript con 6 comandi di sostituzione sequenziale, per ogni cifra di input.

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

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

Quindi, applicare le sostituzioni, rimuovere tutte le righe di input che hanno almeno una cifra rimasta, stampare la prima riga corrispondente (la stringa di tempo originale viene estratta dallo spazio di attesa 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

Test

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

Provalo online!

Kotlin , 396 391 389 byte

Nessun indizio su come ridurlo. Sto pensando che sia il doppio di ciò che è possibile. Produce il primo tempo. Grazie a Kevin per 7 byte!

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

Provalo online!

MATL , 31 30 byte

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

Provalo online!

L'input è di 6 numeri interi, l'output è l'ora, i minuti e i secondi minimi in un array. Arresti anomali per input in cui non è possibile tale tempo.

(-1 byte grazie a @Luis Mendo.)

Perl 6 , 43 byte

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

Provalo online!

Si aspetta un array di input ordinato. Restituisce Nilper input non valido.

Stax , 15 byte

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

Esegui ed esegui il debug

Richiede una stringa di cifre ordinate per l'input. Restituisce la prima permutazione che soddisfa alcuni criteri.

• lessicograficamente inferiore a "24"
• tutte e tre le coppie di caratteri sono lessicograficamente inferiori a "6"

Retina , 58 47 byte

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

Provalo online!

L'immissione è di 6 cifre in ordine ordinato. L'output è di 6 cifre che rappresentano il primo tempo valido o una stringa vuota se non esiste un tempo valido.

EDIT: ero un idiota, -9 byte

Spiegazione

Algoritmo

Per brevità, definiamo una cifra bassa come 0-5 e una cifra alta come 6-9.

Innanzitutto, riorganizzare le cifre in modo che "bassa" o "alta" di ciascuna posizione sia corretta. La disposizione corretta, per ogni numero di cifre alte nell'input:

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

Poiché l'eventuale riarrangiamento fallirebbe il controllo finale nell'input ha 4+ cifre alte, possiamo ignorare completamente quel caso.

Quindi, ordina i minimi e gli alti singolarmente. Combinandolo con il riarrangiamento, questo fornisce il valore più basso che soddisfa i vincoli dei minuti e dei secondi. Quindi questo dà il primo tempo valido, se ne esiste uno.

Infine, controlla se abbiamo tempo valido. In caso contrario, scartare la stringa.

Programma

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

Abbina LHHe scambia le prime due cifre in quella (diventa HLH), e ripeti fino a quando non piùLHH esiste . Questo dà la disposizione corretta.

In realtà, ho mentito. Non è necessario alcun ordinamento perché 1) lo scambio avviene solo tra cifre adiacenti e solo tra un minimo e un massimo; e 2) l'ingresso è ordinato. Quindi i minimi e gli alti singolarmente sono già in ordine.

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

Mantiene la stringa solo se è un tempo valido