Pierwotnie opublikowany (i usunięty) przez @Tlink , który najprawdopodobniej został zainspirowany tym pytaniem StackOverflow .
Ponieważ szkoda, że ​​został usunięty, ponieważ ogólnie wydawało się to sporym wyzwaniem, pomyślałem, że opublikuję go z odpowiednim formatowaniem i regułami. (Próbowałem skontaktować się z @Tlink i uzyskać jego zgodę na opublikowanie go, ale on nie odpowiada już, dlatego postanowiłem to teraz opublikować.)

Wprowadzanie: sześć cyfr.

Dane wyjściowe: pierwszy lub ostatni prawidłowy czas w formacie 24-godzinnym ( 00:00:00do 23:59:59). (Możesz sam wybrać, czy wyprowadzasz pierwszy, czy ostatni prawidłowy czas.)

Przykład:

Gdy dane wejściowe są 1,8,3,2,6,4, można utworzyć następujące czasy:

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

Więc wyprowadzimy jeden 12:36:48lub 23:48:16w tym przypadku, odpowiednio jako pierwszy / ostatni.

Zasady konkursu:

• Podaj, czy podajesz w odpowiedzi pierwszy lub ostatni prawidłowy czas.
• I / O jest elastyczny. Wejściem może być sześć oddzielnych liczb całkowitych; ciąg zawierający sześć cyfr; lista / tablica liczb całkowitych; pojedyncza (ewentualnie ósemkowa) liczba; itp. Wyjściem może być poprawnie uporządkowana lista / tablica cyfr; ciąg znaków w formacie HH:mm:ss/ HHmmss/ HH mm ss; każda cyfra drukowana z separatorem nowej linii; itp. Twoje połączenie.
• Dozwolone jest przyjmowanie cyfr w dowolnej kolejności, dzięki czemu można je już sortować od najniższej do najwyższej lub odwrotnie.
• Jeśli nie można utworzyć prawidłowego czasu z podanymi cyframi (tj. 2,5,5,5,5,5), Zaznacz to w dowolny sposób. Może zwrócić null/ false; "Not possible"; awaria z błędem; itp. (Nie można podać niepoprawnego czasu, takiego jak 55:55:52lub innego prawidłowego czasu, takiego jak 00:00:00.) Podaj, jak obsługuje dane wejściowe, dla których nie można utworzyć prawidłowego czasu.
• Nie możesz podać wszystkich możliwych prawidłowych czasów. Tylko najwcześniejsze / najnowsze powinny być wyprowadzone / zwrócone.
• 24godziny (tj. 24:00:00) lub 60minuty / sekundy (tj. 00:60:60) są nieprawidłowe. Zakresy dotyczą [00-23]godzin oraz [00-59]minut i sekund.

Główne zasady:

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
  Nie pozwól, aby języki gry w golfa zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
• Do odpowiedzi mają zastosowanie standardowe reguły , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami i zwracanymi typami, pełnych programów. Twoja decyzja.
• Domyślne luki są zabronione.
• Jeśli to możliwe, dodaj link z testem swojego kodu.
• W razie potrzeby dodaj również wyjaśnienie.

Przypadki testowe:

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 bajtów

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

Wypróbuj online!

-12 bajtów dzięki Kevin Cruijssen

Prawdopodobnie nie jest optymalny, ale działa. Dziwne, z jakiegoś powodu, z 7 argumentami, implementacja gcc na TIO wymaga, abyś faktycznie je dostarczył lub segfault. Na moim komputerze jest to jednak niepotrzebne.

Format: G (X, 0,6) -> Y, gdzie X jest liczbą 6-cyfrową, której cyfry mają być użyte, a Y jest liczbą 6 cyfr, która przy uwzględnieniu czasu (poprzez wstawienie: odpowiednio) jest minimalna.

Haskell , 114 96 86 bajtów

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

Teraz z mniej ścisłą wydajnością. Pobiera dane wejściowe jako ciąg cyfr i porównuje permutacje z limitami z porównaniem listy. W minutach i sekundach sprawdzana jest tylko pierwsza cyfra. Awarie i poparzenia, jeśli brak permutacji jest prawidłowym czasem.

Wypróbuj online!

Python 2 , 131 115 112 109 105 88 bajtów

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

Wypróbuj online!

I / O to listy liczb całkowitych

Zgłasza błąd, jeśli nie jest to możliwe

Alternatywny:

Python 2 , 88 bajtów

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

Wypróbuj online!

Zwraca ostatni czas

Zwraca pustą krotkę dla niepoprawnych czasów

Zapisano

• -21 bajtów, dzięki ovs

05AB1E , 20 15 bajtów

Wprowadź jako posortowany ciąg.
Wyjście to najmniejszy czas w postaci ciągu.
W przypadku braku rozwiązania wynikiem jest pusta lista.

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

Wypróbuj online!

JavaScript (ES6), 93 89 88 bajtów

Oczekuje tablicy 6 cyfr posortowanych od najniższej do najwyższej. Zwraca 6-cyfrowy ciąg pierwszego ważnego czasu lub falsejeśli nie ma rozwiązania.

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

Wypróbuj online!

Skomentował

Rekurencyjnie wypróbowujemy wszystkie permutacje danych wejściowych, dopóki nie znajdziemy takiej, która przejdzie test hybrydowy przy użyciu zarówno arytmetyki, jak i wyrażenia regularnego.

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 bajtów

Pobiera dane wejściowe jako ciąg cyfr i wyprowadza pierwszy prawidłowy czas; zapętla się w nieskończoność, jeśli nie ma ważnego czasu.

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

Spróbuj

Ostrzeżenie: bardzo wolno - dodaj *1000po drugiej, Xaby nieco przyspieszyć. I nie zapominaj, że nieprawidłowe wejście utworzy nieskończoną pętlę i może spowodować awarię przeglądarki.

Wyjaśnienie

                   :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 bajtów

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

Wypróbuj online! Zwraca najwcześniejszy czas lub pusty ciąg, jeśli nie można znaleźć czasu. Edycja: Zapisano 5 8 bajtów dzięki @TwiNight. Wyjaśnienie:

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

Wygeneruj wszystkie permutacje. :Działa jego sposób choć jako ciąg permutacji są generowane, kończąc na początku.

O`

Sortuj godziny w kolejności.

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

Podaj pierwszy prawidłowy czas.

Czerwony , 157 124 bajtów

Dziękuję Kevinowi Cruijssenowi za przypomnienie, żebym uważniej czytał opisy!

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

Wypróbuj online!

Pobiera posortowany ciąg jako dane wejściowe. Zwraca, nonejeśli nie można uzyskać czasu.

Wyjaśnienie:

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 bajtów

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

Wypróbuj online!

Arnauld zapisał bajt. Dzięki!

Oczekuje listy ['1','2','3','4','6','8']w kolejności posortowanej:

Dozwolone jest przyjmowanie cyfr w dowolnej kolejności, dzięki czemu można je już sortować od najniższej do najwyższej lub odwrotnie.

123648Zwraca liczbę całkowitą jak dla 12:36:48. Mam nadzieję, że to możliwe.

Galaretka , 15 bajtów

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

Wypróbuj online!

Wysłane po prośbie. Podejście jest takie samo jak jedno z pozostałych, jednak odpowiedź ta została opracowana niezależnie.

Japt , 39 23 bajtów

Jestem pewien, że jest to krótszy sposób, ale chciałem spróbować użyć obiektów Date w 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.

Pobiera dane wejściowe jako posortowaną tablicę liczb, zwraca ostatni prawidłowy czas lub puste dane wyjściowe, jeśli nie istnieje.
Stracił 10 funtów bajtów dzięki Kudłatemu .

Wypróbuj tutaj .

Rubin , 68 67 62 56 55 bajtów

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

Wypróbuj online!

Dane wejściowe: Posortowana tablica cyfr (jako liczby całkowite).

Dane wyjściowe: tablica cyfr lub niljeśli nie znaleziono rozwiązania

Galaretka , 17 bajtów

^{Jestem prawie pewien, że to nie jest najkrótsze podejście ... przyjrzymy się temu później :)}

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

Wypróbuj online!

Wolfram Language (Mathematica) , 63 bajty

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

Wypróbuj online!

Pobiera na wejściu posortowaną listę cyfr. Zwraca Missing[NotFound]za nieprawidłowe dane wejściowe.

Wyjaśnienie

Permutations@#

Znajdź wszystkie permutacje danych wejściowych. Ponieważ dane wejściowe są sortowane, zagwarantowane jest, że wszystkie prawidłowe czasy są w porządku rosnącym.

FirstCase[ ... ]

Znajdź pierwszą listę, która pasuje ...

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

Pierwszy element, oznaczony ajest 0, 1 lub 2, a etykieta drugi, trzeci, piąty i elementów b, ci dodpowiednio ...

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

... takich, które a*bsą mniejsze niż 10 di csą mniejsze niż 6, z d >= c.

Trick, że dla wszystkich liczb 00na 24produkt z dwóch cyfr, co najwyżej 9, a ewentualne nieprawidłowe numery 25do 29(od zmusić pierwszą cyfrę 0, 1 lub 2) mają co najmniej 10 produkt.

Pyth , 37 bajtów

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

Zestaw testowy

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 z -palF, 73 bajtami

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

Wypróbuj online!

Wypisuje podobne HHmmssi wyprowadza pusty wiersz dla nieprawidłowych wpisów.

Każda odpowiedź, którą ostatnio zadałem, była używana globdo permutacji ... Dziwne!

Bash + GNU sed, 83 , 72 , 69 bajtów

• Akceptuje dane wejściowe jako 6 oddzielnych argumentów;
• Zwraca najwcześniejszy czas (jeśli został znaleziony);
• Nic nie zwraca (puste wyjście), jeśli nie istnieje poprawna kombinacja.

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

Jak to działa

Wygeneruj wstępnie wszystkie możliwe ciągi czasowe dla znaczników czasu z zakresu od 0 do 86399, używając polecenia GNU-sed e (xecute) + date.

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

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

Wygeneruj sedskrypt z 6 sekwencyjnymi poleceniami podstawiania dla każdej cyfry wejściowej.

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

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

Następnie zastosuj podstawienia, usuń wszystkie linie wejściowe, które mają co najmniej jedną cyfrę, wydrukuj pierwszą pasującą linię (oryginalny ciąg czasu zostanie wyodrębniony z przestrzeni wstrzymania za pomocą 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

Wypróbuj online!

Kotlin , 396 391 389 bajtów

Nie mam pojęcia, jak to zmniejszyć. Myślę, że jest dwa razy więcej niż to możliwe. Produkuje najwcześniej. Dzięki Kevin za 7 bajtów!

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

Wypróbuj online!

MATL , 31 30 bajtów

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

Wypróbuj online!

Wejście to 6 liczb całkowitych, wyjście to minimalna godzina, minuty i sekundy w tablicy. Awarie dla danych wejściowych, w których taki czas nie jest możliwy.

(-1 bajt dzięki @Luis Mendo.)

Perl 6 , 43 bajtów

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

Wypróbuj online!

Oczekuje posortowanej tablicy wejściowej. Zwraca Nilnieprawidłowe dane wejściowe.

Stax , 15 bajtów

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

Uruchom i debuguj

Do wprowadzenia potrzebny jest ciąg posortowanych cyfr. Zwraca pierwszą permutację, która spełnia kilka kryteriów.

• leksykograficznie mniejsza niż „24”
• wszystkie trzy pary znaków są leksykograficznie mniejsze niż „6”

Retina , 58 47 bajtów

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

Wypróbuj online!

Wejście składa się z 6 cyfr w posortowanej kolejności. Dane wyjściowe to 6 cyfr reprezentujących najwcześniejszy prawidłowy czas lub pusty ciąg, jeśli nie istnieje prawidłowy czas.

EDYCJA: Byłem idiotą, -9 bajtów

Wyjaśnienie

Algorytm

Dla zwięzłości zdefiniujmy małą cyfrę jako 0-5, a wysoką cyfrę jako 6-9.

Najpierw zmień kolejność cyfr, aby „niska” lub „wysoka” każdej pozycji była poprawna. Prawidłowe ustawienie dla każdej liczby wysokich cyfr na wejściu:

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

Ponieważ jakiekolwiek przegrupowanie nie powiedzie się, końcowe sprawdzenie na wejściu ma 4+ wysokie cyfry, możemy całkowicie zignorować tę sprawę.

Następnie posortuj indywidualnie minima i maksima. W połączeniu z przegrupowaniem daje to najniższą wartość, która spełnia ograniczenia minutowe i drugie. To daje najwcześniejszy ważny czas, jeśli taki istnieje.

Na koniec sprawdź, czy mamy odpowiedni czas. Jeśli nie, odrzuć ciąg.

Program

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

Dopasowuje LHHi zamienia pierwsze dwie cyfry w tym (staje się HLH) i powtarzaj to, dopóki nie będzie już więcej LHH. Daje to prawidłowe ustawienie.

Właściwie to skłamałem. Sortowanie nie jest konieczne, ponieważ 1) zamiana zachodzi tylko między sąsiednimi cyframi i tylko między niskim a wysokim; i 2) dane wejściowe są posortowane. Tak więc pojedyncze minima i maksima są już posortowane.

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

Zachowuje ciąg tylko wtedy, gdy jest to prawidłowy czas