最初由@Tlink发布（并删除），这很可能是受此StackOverflow问题启发的。
由于很遗憾，它被删除了，因为通常来说这是一个很好的挑战，所以我认为我应该使用适当的格式和规则重新发布它。（我已经尝试联系@Tlink并获得他/她的发布许可，但是他不再回应，这就是为什么我决定现在将其发布。）

输入：六位数。

输出：以24小时格式（00:00:00到23:59:59）的第一个或最后一个有效时间。（您可以选择是输出第一个还是最后一个有效时间。）

例：

输入为时1,8,3,2,6,4，可以创建以下时间：

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

因此，我们将输出12:36:48或23:48:16在这种情况下分别输出第一个/最后一个。

挑战规则：

• 说明您在答案中输出的是第一个还是最后一个有效时间。
• I / O是灵活的。输入可以是六个分开的整数；包含六个数字的字符串；整数列表/数组；单个（可能是八进制）数字；输出可以是正确排序的数字列表/数组；例如 格式为HH:mm:ss/ HHmmss/ 的字符串HH mm ss；用换行符分隔的每个数字；等你的电话。
• 您可以按任意顺序输入数字，因此它们可以从最低到最高进行排序，反之亦然。
• 如果不能使用给定的数字（即2,5,5,5,5,5）创建有效时间，请以任何所需的方式弄清楚。可以返回null/ false; "Not possible"; 因错误而崩溃；等等（您不能输出无效时间，如55:55:52，或其他有效时间，如00:00:00。）请说明其如何处理无法创建有效时间的输入。
• 您不允许输出所有可能的有效时间。仅最早/最新的应该被输出/返回。
• 24数小时（即24:00:00）或60分钟/秒（即00:60:60）无效。范围是[00-23]小时，[00-59]分钟和秒。

一般规则：

• 这是代码高尔夫球，因此最短答案以字节为单位。
  不要让代码高尔夫球语言阻止您发布使用非代码高尔夫球语言的答案。尝试针对“任何”编程语言提出尽可能短的答案。
• 标准规则适用于您的答案，因此允许您使用STDIN / STDOUT，具有适当参数的函数/方法和返回类型的完整程序。你的来电。
• 默认漏洞是禁止的。
• 如果可能，请为您的代码添加一个带有测试的链接。
• 另外，如有必要，请添加说明。

测试用例：

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），186174字节

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

在线尝试！

-12个字节感谢Kevin Cruijssen

可能不是最优的，但它可以工作。基于7个参数，出于某种原因，奇怪的是，在TIO上的gcc实现要求您实际提供它们或它的段错误。在我的机器上，这是不必要的。

格式：G（X，0,6）-> Y，其中X是将要使用其数字的6位数字，而Y是6位数字，当作为时间（通过适当插入：）时，它是最小的。

Haskell，114 96 86字节

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

现在具有不太严格的输出。将输入作为一串数字，并使用列表比较将排列与限制进行比较。使用分钟和秒仅检查第一个数字。如果没有有效的排列时间，则会崩溃并烧毁。

在线尝试！

Python 2中，131个 115 112 109 105 88字节

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

在线尝试！

I / O是整数列表

如果没有时间抛出错误

选择：

Python 2，88字节

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

在线尝试！

返回最新时间

返回无效时间的空元组

已保存

• -21字节，多亏了ovs

05AB1E，20 15字节

输入为已排序的字符串。
输出是作为字符串的最小时间。
如果没有解决方案，则输出为空列表。

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

在线尝试！

JavaScript（ES6），93 89 88字节

期望由6位数字组成的数组，从最低到最高排序。返回第一个有效时间的6位字符串，或者false不存在任何解决方案。

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

在线尝试！

已评论

我们递归地尝试输入的所有排列，直到找到通过算术和正则表达式的混合测试的输入。

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个字节

将输入作为一串数字并输出第一个有效时间；如果没有有效时间，则无限循环。

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

试试吧

警告：速度非常慢-请*1000在第二秒后添加X以加快速度。并且不要忘记，无效的输入将创建无限循环并可能导致浏览器崩溃。

说明

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

视网膜，77 74 69 65 62字节

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

在线尝试！输出最早的时间，如果找不到时间，则输出空字符串。编辑：由于@TwiNight，节省了5 8个字节。说明：

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

生成所有排列。通过:排列生成字符串的方式进行工作，直到开始。

O`

将时间排序。

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

输出第一个有效时间。

红色，157124字节

感谢Kevin Cruijssen提醒我更仔细地阅读说明！

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

在线尝试！

将排序后的字符串作为输入。none如果无法花费时间，则返回。

说明：

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个字节

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

在线尝试！

Arnauld保存了一个字节。谢谢！

期望列表['1','2','3','4','6','8']按排序顺序：

您可以按任意顺序输入数字，因此它们可以从最低到最高进行排序，反之亦然。

输出类似于12364812:36:48 的整数。我希望这是可以接受的。

果冻，15字节

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

在线尝试！

请求后发布。该方法与另一个答案中的一个相同，但是此答案是独立开发的。

Japt，39 23字节

可以肯定，有一种较短的方法可以做到这一点，但是我想尝试在Japt中使用Date对象。

á ®¬ò 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.

将输入作为数字的排序数组，返回最新的有效时间；如果不存在，则返回空输出。由于Shaggy而
丢失了10 磅字节。

在这里尝试。

Ruby，68 67 62 56 55字节

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

在线尝试！

输入：排序的数字数组（整数）。

输出：数字数组或未nil找到解决方案

果冻，17 个字节

^{我几乎可以肯定这不是最短的方法...稍后会再讨论：)}

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

在线尝试！

Wolfram语言（Mathematica），63个字节

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

在线尝试！

需要有序的数字作为输入列表。返回Missing[NotFound]无效输入。

说明

Permutations@#

查找输入的所有排列。由于输入已排序，因此可以确保所有有效时间都按升序排列。

FirstCase[ ... ]

找到第一个匹配的列表...

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

第一元件，标记a，是0，1，或2，并且标记第二，第三，和第五元素b，c和d分别...

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

...使得a*b小于10，和d和c小于6，具有d >= c。

诀窍在于，对于00to的所有数字24，两位数字的乘积最大为9，而25to 的可能无效数字29（因为我们将第一位数字强制为0、1或2）的乘积至少为10。

Pyth，37个字节

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

测试套件

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

具有-palF73个字节的Perl 5

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

在线尝试！

输出类似于，HHmmss并为无效条目输出空白行。

我最近做出的每个答案都使用globing进行排列...很奇怪！

击+ GNU sed的，83，72，69个字节

• 接受输入作为6个单独的参数；
• 返回最早的时间（如果找到）；
• 如果不存在有效的组合，则不返回任何内容（空输出）。

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

怎么运行的

使用GNU-sed e（xecute）命令+ ，为0到86399范围内的时间戳预生成所有可能的时间字符串date。

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

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

sed为每个输入数字生成具有6个顺序替换命令的脚本。

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

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

然后，应用替换，删除至少剩余一位数字的所有输入行，打印第一条匹配行（使用将从保留空间中提取原始时间字符串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

测试

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

在线试用！

科特林，396个 391 389字节

不知道如何缩小尺寸。我认为这是可能的两倍。产生最早的时间。感谢Kevin提供7个字节！

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

在线尝试！

MATL，31 30字节

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

在线尝试！

输入是6个整数，输出是数组中的最小小时，分钟和秒。在没有这种时间的情况下输入崩溃。

（感谢@Luis Mendo，-1个字节。）

Perl 6、43字节

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

在线尝试！

需要一个排序的输入数组。返回Nil无效输入。

Stax，15 个字节

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

运行并调试

它需要一串排序的数字来输入。它返回满足一些条件的第一个排列。

• 在字典上小于“ 24”
• 在字典上，所有三对字符均小于“ 6”

视网膜，58 47字节

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

在线尝试！

输入为6位数字（按排序顺序）。输出为代表最早有效时间的6位数字，如果没有有效时间，则为空字符串。

编辑：我是一个白痴，-9个字节

说明

算法

为简便起见，我们将低位数字定义为0-5，将高位数字定义为6-9。

首先，重新排列数字，以使每个位置的“低调”或“高调”正确。对于输入中每个高位数的正确排列：

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

由于任何重新排列都将失败，因此输入中的最终检查将有4位以上的高位数字，因此我们可以完全忽略这种情况。

然后，分别对低点和高点进行排序。结合重新排列，这将提供满足分钟和秒约束的最小值。因此，这将提供最早的有效时间（如果存在）。

最后，检查我们是否有有效时间。如果不是，则丢弃该字符串。

程序

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

匹配LHH并交换该字符中的前两位（成为HLH），并重复该操作直到不再LHH存在。这给出了正确的安排。

其实我说谎 无需排序，因为1）交换仅发生在相邻数字之间，仅发生在低位和高位之间；2）对输入进行排序。因此，低点和高点已经分别按顺序排列了。

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

仅在有效时间保留字符串