Dado um número inteiro entre 0 e 141 (inclusive), liste todos os horários de 24 horas cujas unidades de hora, minuto e segunda são adicionadas a esse número inteiro.

Regras de adição

Os números são adicionados por suas unidades de tempo, não por um dígito.

Por exemplo, pegue 17:43:59

17 + 43 + 59 = 119

Lembre-se, este é um exemplo de dígitos sendo adicionados.Na realidade, você digitaria 119 e 17:43:59 seria um dos resultados. A saída deve ser dada como HH: MM: SS ou H: MM: SS.

Lembre-se também de que o número mais alto possível é 141, sendo 23:59:59. Isso é código de golfe, então a menor quantidade vence. Tentativa e erro são permitidos, mas pode haver uma maneira melhor de fazer isso.

Editar: Especifique onde está no seu código o valor de entrada.

Gelatina , 16 30 29 20 bytes

Agora com o formato de saída correto! Muito obrigado a Dennis por sua ajuda na depuração desta resposta. Sugestões de golfe são bem-vindas. Experimente online!

Editar: +14 bytes usando o formato de saída correto. -1 byte de remover um espaço extra. -3 de mudar de 24,60,60para “ð<<‘. -6 bytes de mudar +100DḊ€€para d⁵.

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

Explicação

“ð<<‘Œ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.

Bash, 71

• 8 bytes salvos graças a @hvd

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

Experimente online .

Perl 6 , 62 56 bytes

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

Apenas verifica todas as combinações possíveis no produto cruzado de todas as horas, minutos e segundos.

Python 3 , 91 bytes

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

Existem soluções mais curtas usando exec(Python 2) ou recursão (Python 3), mas ambas requerem uma quantidade razoável de memória.

Experimente online!

PowerShell , 87 77 bytes

Guardado 10 bytes graças a John L. Bevan

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

Experimente online!(isso expirará, é muito lento)

Explicação

Muito simples, começando com o atual [datetime], adicione 1 segundo 86.399 vezes, formate como uma sequência e mantenha apenas os que soma somam.

Haskell, 77 bytes

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

Haskell, 90 bytes

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]

Retorna uma lista de cadeias HH: MM: SS, por exemplo f 140- -> ["22:59:59","23:58:59","23:59:58"].

São três voltas simples através das horas, minutos e segundos. Mantenha e formate todos os valores em que a soma é o número de entrada x.

Pitão - 30 bytes

Leva todos os tempos possíveis e depois filtra.

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

Conjunto de Teste .

Julia 0,5 , 69 bytes

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

Experimente online!

Lote, 168 bytes

@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%

Produz horas de um dígito.

Mathematica, 79 bytes

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

Oitava, 83 , 87 bytes

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

Experimente Online!

QBIC , 82 72 bytes

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

Isso atinge um ponto infeliz no QBasic, com conversão para número, aparando e precedido de um 0 quando necessário é realmente caro.

Saída de amostra:

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

Explicação Eu escrevi um romance sobre isso:

:           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 bytes (versão desagradável)

Como as regras não dizem nada sobre a conclusão em um determinado período de tempo (ou nada) e nada sobre duplicatas, aqui está uma solução horrível:

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

Raquete 39 bytes

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

Ungolfed:

(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 bytes

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

Experimente online!

Explicação

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 bytes

Toma uma string vazia adicional como entrada, que eu presumo que não conta para o tamanho. Bytecount atualizado (incluindo histórico) para adicionar dois bytes para a inicialização da string.

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

Menos golfe

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
}

Teste

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 bytes

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

Visualização expandida:

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

Faça um loop em todos os momentos possíveis, fazendo um loop de 86399 a 1,

• converter o número inteiro em tempo, dividindo por 3600 para obter o primeiro dígito
• o segundo dígito, tomando o número inteiro mod 3600 e depois dividindo por 60
• e o último dígito é o número inteiro mod 60

Subtraia todos os 3 números do valor de entrada para retornar um valor de falsey se os três números somarem o valor de entrada. Se o valor for falsey, produza o valor.

bash, 78 bytes (usando um utilitário BSD) ou 79 bytes (também não BSD)

Isso é um pouco mais longo do que a @DigitalTrauma e a boa solução de 71 bytes do @ hvd, mas eu meio que gostei da idéia aqui de usar números na base 60; Estou curioso para saber se alguém pode jogar golfe um pouco mais.

Com o utilitário jot padrão BSD:

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

Com o utilitário seq mais universalmente disponível:

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

A idéia é gerar os números de 0 a 83699 e usar dc para convertê-los na base 60. Os "dígitos" na saída base-dc de 60 são números de 2 dígitos de 00 a 59, com espaços separando os "dígitos", portanto isso lista todos os horários desejados de 00 00 00 a 23 59 59 quase no formato necessário.

Se você literalmente fizer isso, números abaixo de 60 ^ 2 não são números de 3 dígitos na base 60, então os 00 ou 00 00 iniciais estão ausentes. Por esse motivo, estou gerando os números de 60 ^ 3 a 60 ^ 3 + 83699; isso garante que todos os números gerados tenham exatamente 4 dígitos na base 60. Tudo bem, desde que eu jogue fora o primeiro dígito extra (01) que não for necessário.

Assim, uma vez que os tempos desejados são gerados, eu pego cada quádruplo de 01 00 00 00 a 01 23 59 59, adiciono os últimos três números e subtraio o argumento $ 1. Se for 0, então pego tudo no quádruplo do terceiro caractere (jogando fora o "01"), use tr para converter espaços em dois pontos e imprima o resultado.

PowerShell , 91 97 bytes (incluindo entrada)

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,$_}}}

ou

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

Expandido e comentado

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, $_
        }
    }
}

Nota: Superado pela versão do @ Briantist: /codegolf//a/105163/6776