给定一个介于0和141（含）之间的整数，请列出所有24小时制，其小时，分钟和秒单位加到该整数上。

加法规则

数字是按其时间单位而不是一位数字相加的。

例如，以17:43:59

17 + 43 + 59 = 119

请记住，这是添加数字的示例。实际上，您将输入119，而17:43:59将是结果之一。输出应为HH：MM：SS或H：MM：SS。

另外请记住，最大数目可能是141，即23:59:59。这是代码高尔夫球，因此赢利最少。允许反复试验，但是可能有更好的方法来解决此问题。

编辑：请指定输入值在代码中的何处。

果冻，16 30 29 20字节

现在具有正确的输出格式！非常感谢Dennis调试此答案的帮助。欢迎打高尔夫球。在线尝试！

编辑：使用正确的输出格式时+14个字节。从-1个字节中删除多余的空间。-3从更改24,60,60为“ð<<‘。从更改+100DḊ€€为-6个字节d⁵。

“ð<<‘Œp’S=¥Ðfd⁵j€”:Y

说明

“ð<<‘Œp’S=¥Ðfd⁵j€”:Y  Main link. Argument: n

“ð<<‘                 Jelly ord() the string `ð<<` to get [24, 60, 60]. Call this list z.
     Œp               Cartesian product of z's items. 
                        Since each item of z is a literal,
                        Jelly takes the range [1 ... item] for each item.
       ’              Decrements every number in the Cartesian product 
                        to get lowered ranges [0 ... item-1].
        S=¥           Create a dyadic link of `sum is equal to (implicit n)`.
           Ðf         Filter the Cartesian product for items with sum equal to n.
             d⁵       By taking divmod 10 of every number in each item,
                        we get zero padding for single-digit numbers
                        and every double-digit number just turns into a list of its digits.
               j€”:   Join every number with a ':'.
                   Y  Join all of the times with linefeeds for easier reading.

巴什71

• @hvd节省了8个字节

for t in {0..23}+{00..59}+{00..59};{((${t//+0/+}-$1))||echo ${t//+/:};}

在线尝试。

Perl 6的，62 56个字节

{map *.fmt('%02d',':'),grep $_==*.sum,(^24 X ^60 X ^60)}

只需检查所有小时，分钟和秒的叉积中的所有可能组合。

Python 3，91字节

def f(n):
 for k in range(86400):t=k//3600,k//60%60,k%60;sum(t)==n!=print('%d:%02d:%02d'%t)

使用exec（Python 2）或递归（Python 3）的解决方案较短，但是两者都需要不合理的内存量。

在线尝试！

PowerShell，87 77字节

由于约翰·L·贝文节省了10个字节

$d=date;0..86399|%{$d+=1e7l;"$d".Split()[1]}|?{("{0:H+m+s}"-f$d|iex)-in$args}

在线尝试！（这会超时，非常慢）

说明

非常简单，从current开始[datetime]，添加1秒86,399次，格式为字符串，然后仅保留求和的值。

Haskell，77个字节

f x=[tail$(':':).tail.show.(+100)=<<t|t<-mapM(\x->[0..x])[23,59,59],sum t==x]

Haskell，90个字节

p x=['0'|x<10]++show x
i=[0..59]
f x=[p h++':':p m++':':p s|h<-[0..23],m<-i,s<-i,h+m+s==x]

返回HH：MM：SS字符串的列表，例如f 140-> ["22:59:59","23:58:59","23:59:58"]。

通过小时，分钟和秒，这是三个简单的循环。保留并格式化所有总和为输入数字的值x。

Pyth-30个字节

花费所有可能的时间然后过滤。

mj\:%L"%02d"dfqsTQsM*U24*KU60K

测试套件。

朱莉娅 0.5，69字节

!n=[h+m+s==n&&@printf("%d:%02d:%02d
",h,m,s)for s=0:59,m=0:59,h=0:23]

在线尝试！

批处理，168字节

@for /l %%t in (0,1,86399)do @call:c %1 %%t
@exit/b
:c
@set/ah=%2/3600,m=%2/60%%60,s=%2%%60,n=%1-h-m-s
@set m=0%m%
@set s=0%s%
@if %n%==0 echo %h%:%m:~-2%:%s:~-2%

输出单位数小时。

Mathematica，79个字节

Cases[Tuples@{(r=Range)@24-1,x=r@60-1,x},t_/;Tr@t==#:>DateString@TimeObject@t]&

八度，83，87个字节

@(a){[H,M,S]=ndgrid(0:23,s=0:59,s);printf("%d:%02d:%02d\n",[H(x=H+M+S==a),M(x),S(x)]')}

在线尝试！

QBIC，82 72字节

:[0,23|[0,59|[0,59|~b+c+d=a|?!b$+@:`+right$(@0`+!c$,2)+A+right$(B+!d$,2)

这在QBasic中很不幸，因为将其转换为数字，修剪和0在必要时添加前缀确实非常昂贵。

样本输出：

Command line: 119
1:59:59
2:58:59
2:59:58
3:57:59
[... SNIP 270 lines ...]
23:58:38
23:59:37

解释我写了一本关于它的小说：

:           Get N, call it 'a'
[0,23|      Loop through the hours; this FOR loop is initialised with 2 parameters
            using a comma to separate FROM and TO, and a '|' to delimit the argument list
[0,59|      Same for the minutes
[0,59|      And the seconds
            QBIC automatically creates variables to use as loop-counters: 
            b, c, d (a was already taken by ':')
~b+c+d=a    IF a == b+c+d
|           THEN
 ?          PRINT
  !         CAST
   b        'b'
    $       To String; casting num to str in QBasic adds a space, this is trimmed in QBIC
+@:`        Create string A$, containing ":"
+right$      This is a QBasic function, but since it's all lowercase (and '$' is 
            not a function in QBIC) it remains unaltered in the resulting QBasic.
(@0`+!c$,2) Pad the minutes by prepending a 0, then taking the rightmost 2 characters.
+A          Remember that semicolon in A$? Add it again
+right$     Same for the seconds
(B+!d$,2)   Reusing the 0-string saves 2 bytes :-)

PowerShell，67 79字节（讨厌的版本）

由于这些规则并没有说明在一定时间内（或根本没有完成），也没有关于没有重复的内容，因此这是一个可怕的解决方案：

for(){if(("{0:H+m+s}"-f($d=date)|iex)-in$args){"{0:H:mm:ss}"-f$d}}

拍子39字节

(for*/sum((h 24)(m 60)(s 60))(+ h m s))

取消高尔夫：

(for*/sum      ; loop for all combinations; return sum of values for each loop
   ((h 24)     ; h from 0 to 23
    (m 60)     ; m from 0 to 59
    (s 60))    ; s from 0 to 59
  (+ h m s))   ; sum of all 3 variables

MATL，29个字节

24:q60:qt&Z*t!si=Y)'%i:'8:)&V

在线尝试！

说明

24:q     % Push [0 1 ... 23]
60:q     % Push [0 1 ... 59]
t        % Duplicate
&Z*      % Cartesian product of the three arrays. This gives a matrix with each
         % on a different row Cartesian tuple
t!       % Push a transposed copy
s        % Sum of each column
i=       % Logical mask of values that equal the input
Y)       % Select rows based on that mask
'%i:'    % Push this string
8:)      % Index (modularly) with [1 2 ... 8]: gives string '%i:%i:%i'
&V       % Convert to string with that format specification. Implicitly display

JavaScript， 122 120字节

接受一个额外的空字符串作为输入， 我认为这不计入尺寸。更新了字节数（包括历史记录），以添加两个字节来初始化字符串。

console.log((
//Submission starts at the next line
i=>o=>{for(h=24;h--;)for(m=60;m--;)for(s=60;s--;)if(h+m+s==i)o+=`${h}:0${m}:0${s} `;return o.replace(/0\d{2}/g,d=>+d)}
//End submission
)(prompt("Number:",""))(""))

JavaScript（ES6），110

v=>eval("o=[];z=x=>':'+`0${x}`.slice(-2);for(m=60;m--;)for(s=60;s--;h>=0&h<24&&o.push(h+z(m)+z(s)))h=v-m-s;o")

少打高尔夫球

v=>{
  o=[];
  z=x=>':' + `0${x}`.slice(-2);
  for(m = 60; m--;)
    for(s = 60; s--; )
      h = v - m - s,
      h >= 0 & h < 24 && o.push(h + z(m) + z(s))
  return o
}

测试

F=
v=>eval("o=[];z=x=>':'+`0${x}`.slice(-2);for(m=60;m--;)for(s=60;s--;h>=0&h<24&&o.push(h+z(m)+z(s)))h=v-m-s;o")

function update() {
  O.textContent=F(+I.value).join`\n`
}

update()

<input id='I' value=119 type=number min=0 max=141 oninput='update()'><pre id=O></pre>

JavaScript，96个字节

v=>{for (i=86399;i;[a,b,c]=[i/3600|0,i%3600/60|0,i--%60]){v-a-b-c?0:console.log(a+":"+b+":"+c)}}

展开的视图：

v => {
    for (i = 86399; i;
        [a, b, c] = [i / 3600 | 0, i % 3600 / 60 | 0, i-- % 60]) {
        v - a - b - c ? 0 : console.log(a + ":" + b + ":" + c)
    }
}

通过将86399循环为1，循环遍历所有可能的时间

• 用3600除以将整数转换为时间，以获得第一个数字
• 通过取整数mod 3600然后除以60得到第二个数字
• 最后一位是整数mod 60

如果三个数字加起来等于输入值，则从输入值中减去所有三个数字以返回假值。如果该值为false，则输出该值。

bash，78个字节（使用BSD实用程序）或79个字节（也非BSD）

这比@DigitalTrauma和@hvd的漂亮的71字节bash解决方案要长一点，但是我有点喜欢这里使用以60为底的数字的想法。我很好奇是否有人可以再打一点。

使用BSD标准的jot实用程序：

jot '-wx=`dc<<<60do3^%d+n`;((`dc<<<$x++'$1'-n`))||tr \  :<<<${x:3}' 86400 0|sh

使用更通用的seq实用程序：

seq '-fx=`dc<<<60do3^%.f+n`;((`dc<<<$x++'$1'-n`))||tr \  :<<<${x:3}' 0 86399|sh

想法是生成从0到83699的数字，并使用dc将其转换为以60为基数。dc的base-60输出中的“数字”是从00到59的2位数字，中间用空格分隔“数字”，因此它以几乎所需的格式列出了从00 00 00到23 59 59的所有所需时间。

但是，如果按字面意义执行，则60 ^ 2以下的数字不是以60为基数的3位数字，因此缺少开头的00或00 00。因此，我实际上是在生成从60 ^ 3到60 ^ 3 + 83699的数字。这样可以确保在基数60中生成的所有数字都恰好是4位数字。只要我最终将不需要的多余第一位数字（01）丢掉，就可以了。

因此，一旦生成了所需的时间，我就将每个四元组从01 00 00 00提取到01 23 59 59，将最后三个数字相加并减去参数$ 1。如果该值为0，则将第三个字符中的所有字符都从第三个字符开始（丢弃“ 01”），使用tr将空格转换为冒号，然后打印结果。

PowerShell，91 97字节（包括输入）

param($x)1..864e3|%{($d=date($_*1e7l))}|?{("{0:H+m+s}"-f$_|iex)-eq$x}|%{"{0:H:mm:ss}"-f$_}

param($x)0..23|%{$h=$_;0..59|%{$m=$_;0..59|?{$h+$m+$_-eq$x}|%{"{0:0}:{1:00}:{2:00}"-f$h,$m,$_}}}

要么

param($x)0..23|%{$h=$_;0..59|?{($s=$x-$h-$_)-le59-and$s-ge0}|%{"{0:0}:{1:00}:{2:00}"-f$h,$_,$s}} <\ s>

展开并评论

param($x)
#loop through the hours
0..23 | %{
    $h=$_
    #loop through the minutes
    0..59 | %{
        $m=$_
        #loop through the seconds
        0..59 | ?{ #filter for those where the sum matches the target
            $h + $m + $_ -eq $x
        } | %{
            #format the result
            "{0:#0}:{1:00}:{2:00}" -f $h, $m, $_
        }
    }
}

NB：被@Briantist版本超越：https ://codegolf.stackexchange.com/a/105163/6776