Được đăng lần đầu (và bị xóa) bởi @Tlink , rất có thể được lấy cảm hứng từ câu hỏi StackOverflow này .
Vì nó là một sự xấu hổ nên nó đã bị xóa, bởi vì nó có vẻ như là một thử thách tốt nói chung, tôi nghĩ rằng tôi đã đăng lại nó với định dạng và quy tắc phù hợp. (Tôi đã cố gắng liên hệ với @Tlink và nhận được ông cho phép / cô ấy để gửi nó, nhưng (s) ông không trả lời nữa, đó là lý do tôi quyết định đăng nó bản thân mình bây giờ.)

Đầu vào: Sáu chữ số.

Đầu ra: Thời gian hợp lệ đầu tiên hoặc cuối cùng ở định dạng 24 giờ ( 00:00:00thông qua 23:59:59). (Bạn có thể chọn chính mình cho dù bạn xuất thời gian hợp lệ đầu tiên hoặc cuối cùng.)

Thí dụ:

Khi các đầu vào là 1,8,3,2,6,4, các lần sau có thể được tạo:

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

Vì vậy, chúng tôi sẽ xuất 12:36:48hoặc 23:48:16trong trường hợp này, lần đầu tiên / cuối cùng.

Quy tắc thử thách:

• Cho biết bạn xuất thời gian hợp lệ đầu tiên hoặc cuối cùng trong câu trả lời của bạn.
• I / O là linh hoạt. Đầu vào có thể là sáu số nguyên riêng biệt; một chuỗi chứa sáu chữ số; một danh sách / mảng số nguyên; một số duy nhất (có thể là bát phân); vv Đầu ra có thể là một danh sách / mảng các chữ số được sắp xếp chính xác; một chuỗi ở định dạng HH:mm:ss/ HHmmss/ HH mm ss; mỗi chữ số được in bằng dấu phân cách dòng mới; vv Cuộc gọi của bạn.
• Bạn được phép lấy các chữ số theo bất kỳ thứ tự nào bạn muốn, vì vậy chúng có thể được sắp xếp từ thấp nhất đến cao nhất hoặc ngược lại.
• Nếu không có thời gian hợp lệ có thể được tạo bằng các chữ số đã cho (nghĩa là 2,5,5,5,5,5), hãy làm rõ ràng theo bất kỳ cách nào bạn muốn. Có thể trở lại null/ false; "Not possible"; sự cố với một lỗi; v.v. (Bạn không thể xuất thời gian không hợp lệ như 55:55:52hoặc thời gian hợp lệ khác như 00:00:00.) Vui lòng cho biết cách xử lý các đầu vào mà không có thời gian hợp lệ nào có thể được tạo.
• Bạn không được phép xuất tất cả các lần hợp lệ có thể. Chỉ sớm nhất / muộn nhất nên được xuất / trả lại.
• 24trong nhiều giờ (tức là 24:00:00) hoặc 60trong vài phút / giây (tức là 00:60:60) không hợp lệ. Các phạm vi là [00-23]trong nhiều giờ và [00-59]trong vài phút và giây.

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Các quy tắc chuẩn áp dụng cho câu trả lời của bạn, vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, các chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn.
• Ngoài ra, xin vui lòng thêm một lời giải thích nếu cần thiết.

Các trường hợp thử nghiệm:

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

Hãy thử trực tuyến!

-12 byte nhờ Kevin Cruijssen

Có lẽ không tối ưu, nhưng nó hoạt động. Thật kỳ lạ vì một số lý do với 7 đối số, việc triển khai gcc trên TIO yêu cầu bạn thực sự cung cấp cho họ hoặc nó tách biệt. Trên máy của tôi đó là không cần thiết tuy nhiên.

Định dạng: G (X, 0,6) -> Y trong đó X là số có 6 chữ số có chữ số được sử dụng và Y là số có 6 chữ số mà khi được sử dụng theo thời gian (bằng cách chèn: một cách thích hợp) là tối thiểu.

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

Bây giờ với đầu ra ít nghiêm ngặt hơn. Đưa đầu vào dưới dạng một chuỗi các chữ số và so sánh các hoán vị so với các giới hạn với so sánh danh sách. Với phút và giây chỉ có chữ số đầu tiên được kiểm tra. Tai nạn và bỏng nếu không có hoán vị là một thời gian hợp lệ.

Hãy thử trực tuyến!

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*

Hãy thử trực tuyến!

I / O là danh sách các số nguyên

Ném một lỗi nếu không có thời gian là có thể

Thay thế:

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*

Hãy thử trực tuyến!

Trả lại lần gần nhất

Trả về một tuple trống cho thời gian không hợp lệ

Đã lưu

• -21 byte, nhờ có lò nướng

05AB1E , 20 15 byte

Nhập như chuỗi đã sắp xếp.
Đầu ra là thời gian nhỏ nhất như một chuỗi.
Trong trường hợp không có giải pháp, một danh sách trống là đầu ra.

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

Hãy thử trực tuyến!

JavaScript (ES6), 93 89 88 byte

Yêu cầu một mảng gồm 6 chữ số, được sắp xếp từ thấp nhất đến cao nhất. Trả về chuỗi 6 chữ số của lần hợp lệ đầu tiên hoặc falsenếu không có giải pháp nào tồn tại.

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

Hãy thử trực tuyến!

Đã bình luận

Chúng tôi đệ quy thử tất cả các hoán vị của đầu vào cho đến khi chúng tôi tìm thấy một thử nghiệm vượt qua kiểm tra lai bằng cả số học và biểu thức chính quy.

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

Lấy đầu vào dưới dạng một chuỗi các chữ số và xuất thời gian hợp lệ đầu tiên; vòng lặp vô hạn nếu không có thời gian hợp lệ.

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

Thử nó

Cảnh báo: Cực kỳ chậm - thêm *1000sau giây Xđể tăng tốc phần nào. Và đừng quên rằng một đầu vào không hợp lệ sẽ tạo ra một vòng lặp vô hạn và có thể làm sập trình duyệt của bạn.

Giải trình

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

Võng mạc , 77 74 69 65 62 byte

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

Hãy thử trực tuyến! Xuất ra thời gian sớm nhất hoặc chuỗi trống nếu không có thời gian có thể được tìm thấy. Chỉnh sửa: Đã lưu 5 8 byte nhờ @TwiNight. Giải trình:

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

Tạo tất cả các hoán vị. Công :việc theo cách của nó mặc dù chuỗi như hoán vị được tạo ra, kết thúc khi bắt đầu.

O`

Sắp xếp thời gian theo thứ tự.

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

Đầu ra thời gian hợp lệ đầu tiên.

Màu đỏ , 157 124 byte

Cảm ơn Kevin Cruijssen đã nhắc nhở tôi đọc những suy nghĩ cẩn thận hơn!

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

Hãy thử trực tuyến!

Lấy một chuỗi được sắp xếp làm đầu vào. Trả về nonenếu không thể tạo ra thời gian.

Giải trình:

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

Hãy thử trực tuyến!

Arnauld đã lưu một byte. Cảm ơn!

Yêu cầu một danh sách như ['1','2','3','4','6','8']theo thứ tự sắp xếp:

Bạn được phép lấy các chữ số theo bất kỳ thứ tự nào bạn muốn, vì vậy chúng có thể được sắp xếp từ thấp nhất đến cao nhất hoặc ngược lại.

123648Xuất ra một số nguyên như cho 12:36:48. Tôi hy vọng điều đó được chấp nhận.

Thạch , 15 byte

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

Hãy thử trực tuyến!

Đăng sau một yêu cầu. Cách tiếp cận giống như một trong những câu trả lời khác, tuy nhiên câu trả lời này được phát triển độc lập.

Japt , 39 23 byte

Khá chắc chắn rằng có một cách ngắn hơn để làm điều này, nhưng tôi muốn thử sử dụng các đối tượng Date trong 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.

Lấy đầu vào dưới dạng một dãy số được sắp xếp, trả về thời gian hợp lệ mới nhất hoặc đầu ra trống nếu không tồn tại.
Mất 10 pound byte nhờ Shaggy .

Hãy thử nó ở đây .

Ruby , 68 67 62 56 55 byte

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

Hãy thử trực tuyến!

Đầu vào: Sắp xếp mảng các chữ số (dưới dạng số nguyên).

Đầu ra: Mảng các chữ số hoặc nilnếu không tìm thấy giải pháp

Thạch , 17 byte

^{Tôi gần như chắc chắn đây không phải là cách tiếp cận ngắn nhất ... sẽ xem xét lại điều này sau :)}

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

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 63 byte

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

Hãy thử trực tuyến!

Đưa ra một danh sách sắp xếp các chữ số làm đầu vào. Trả về Missing[NotFound]cho đầu vào không hợp lệ.

Giải trình

Permutations@#

Tìm tất cả các hoán vị của đầu vào. Vì đầu vào được sắp xếp, đảm bảo rằng tất cả các lần hợp lệ đều theo thứ tự tăng dần.

FirstCase[ ... ]

Tìm danh sách đầu tiên phù hợp với ...

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

Yếu tố đầu tiên, dán nhãn a, là 0, 1, hoặc 2, và gắn nhãn thứ hai, thứ ba, thứ năm và các yếu tố b, cvà dtương ứng ...

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

... như vậy a*blà ít hơn 10, và dvà cít hơn 6, với d >= c.

Bí quyết là đối với tất cả các số 00tới 24, các sản phẩm của hai chữ số là tại hầu hết 9, và những con số không hợp lệ có thể 25đến 29(kể từ khi chúng tôi buộc các chữ số đầu tiên là 0, 1, hoặc 2) có sản phẩm của ít nhất 10.

Bình thường , 37 byte

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

Bộ kiểm tra

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

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

Hãy thử trực tuyến!

Đầu ra thích HHmmssvà xuất một dòng trống cho các mục không hợp lệ.

Mỗi câu trả lời tôi đã thực hiện gần đây đã sử dụng globing cho hoán vị ... Thật kỳ lạ!

Bash + GNU sed, 83 , 72 , 69 byte

• Chấp nhận đầu vào là 6 đối số riêng biệt;
• Trả về thời gian sớm nhất (nếu tìm thấy);
• Trả về không có gì (đầu ra trống) nếu không có kết hợp hợp lệ tồn tại.

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

Làm thế nào nó hoạt động

Tạo trước tất cả các chuỗi thời gian có thể, cho các dấu thời gian trong phạm vi 0 đến 86399, sử dụng lệnh GNU-sed e (xecute) + date.

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

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

Tạo sedtập lệnh với 6 lệnh thay thế tuần tự, cho mỗi chữ số đầu vào.

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

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

Sau đó, áp dụng thay thế, xóa bất kỳ dòng đầu vào nào còn lại ít nhất một chữ số, in dòng phù hợp đầu tiên (chuỗi thời gian ban đầu được trích xuất từ ​​không gian giữ với 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

Kiểm tra

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

Dùng thử trực tuyến!

Kotlin , 396 391 389 byte

Không có manh mối làm thế nào để làm cho điều này nhỏ hơn. Tôi nghĩ rằng nó là gấp đôi những gì có thể. Sản xuất sớm nhất. Cảm ơn Kevin vì 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]}"}()

Hãy thử trực tuyến!

MATL , 31 30 byte

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

Hãy thử trực tuyến!

Đầu vào là 6 số nguyên, đầu ra là giờ, phút và giây tối thiểu trong một mảng. Sự cố cho đầu vào mà không có thời gian như vậy là có thể.

(-1 byte nhờ @Luis Mendo.)

Perl 6 , 43 byte

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

Hãy thử trực tuyến!

Mong đợi một mảng đầu vào được sắp xếp. Trả vềNil đầu vào không hợp lệ.

Stax , 15 byte

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

Chạy và gỡ lỗi nó

Nó nhận một chuỗi các chữ số được sắp xếp cho đầu vào. Nó trả về hoán vị đầu tiên thỏa mãn một vài tiêu chí.

• từ vựng nhỏ hơn "24"
• cả ba cặp ký tự đều có từ vựng nhỏ hơn "6"

Võng mạc , 58 47 byte

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

Hãy thử trực tuyến!

Đầu vào là 6 chữ số theo thứ tự sắp xếp. Đầu ra là 6 chữ số biểu thị thời gian hợp lệ sớm nhất hoặc chuỗi trống nếu không có thời gian hợp lệ tồn tại.

EDIT: Tôi là một thằng ngốc, -9 byte

Giải trình

Thuật toán

Để cho ngắn gọn, hãy xác định một chữ số thấp là 0-5 và một chữ số cao là 6-9.

Đầu tiên, sắp xếp lại các chữ số sao cho "mức thấp" hoặc "mức cao" của từng vị trí là chính xác. Sắp xếp chính xác, cho mỗi số chữ số cao trong đầu vào:

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

Vì bất kỳ sự sắp xếp lại nào sẽ thất bại, kiểm tra cuối cùng trong đầu vào có hơn 4 chữ số cao, chúng tôi có thể bỏ qua hoàn toàn trường hợp đó.

Sau đó, sắp xếp các mức thấp và mức cao riêng lẻ. Kết hợp với sắp xếp lại, điều này mang lại giá trị thấp nhất thỏa mãn các ràng buộc phút và giây. Vì vậy, điều này cho thời gian hợp lệ sớm nhất, nếu một người tồn tại.

Cuối cùng, kiểm tra xem chúng tôi có thời gian hợp lệ không. Nếu không, loại bỏ chuỗi.

Chương trình

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

Khớp LHHvà hoán đổi hai chữ số đầu tiên trong đó (trở thành HLH) và lặp lại cho đến khi không còn LHHtồn tại. Điều này cho sự sắp xếp chính xác.

Thật ra, tôi đã nói dối. Không cần sắp xếp vì 1) hoán đổi chỉ xảy ra giữa các chữ số liền kề và chỉ giữa mức thấp và mức cao; và 2) đầu vào được sắp xếp. Vì vậy, mức thấp và mức cao riêng lẻ đã được sắp xếp theo thứ tự.

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

Chỉ giữ chuỗi nếu đó là thời gian hợp lệ