Dado un número entero entre 0 y 141 (inclusive), enumere todas las horas de 24 horas cuyas unidades de hora, minuto y segundo se suman a ese número entero.

Reglas de adición

Los números se agregan por sus unidades de tiempo, no por un solo dígito.

Por ejemplo, tome 17:43:59

17 + 43 + 59 = 119

Recuerde, ese es un ejemplo de dígitos agregados. En realidad, ingresaría 119, y 17:43:59 sería uno de los resultados. La salida debe darse como HH: MM: SS o H: MM: SS.

También tenga en cuenta que el número más alto posible es 141, que es 23:59:59. Este es el código de golf, por lo que gana la cantidad más baja. Se permite la prueba y el error, pero puede haber una mejor manera de hacerlo.

Editar: especifique en qué parte de su código se encuentra el valor de entrada.

Jalea , 16 30 29 20 bytes

¡Ahora con el formato de salida correcto! Muchas gracias a Dennis por su ayuda en la depuración de esta respuesta. Sugerencias de golf bienvenidas. Pruébalo en línea!

Editar: +14 bytes del uso del formato de salida correcto. -1 byte al eliminar un espacio extra. -3 de cambiar de 24,60,60a “ð<<‘. -6 bytes de cambiar +100DḊ€€a d⁵.

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

Explicación

“ð<<‘Œ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 guardados gracias a @hvd

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

Pruébalo en línea .

Perl 6 , 62 56 bytes

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

Simplemente verifica todas las combinaciones posibles en el producto cruzado de todas las horas, minutos y 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)

Hay soluciones más cortas que usan exec(Python 2) o recursividad (Python 3), pero ambas requieren una cantidad de memoria irracional.

Pruébalo en línea!

PowerShell , 87 77 bytes

Guardado 10 bytes gracias a John L. Bevan

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

Pruébalo en línea! (esto expirará, es muy lento)

Explicación

Bastante simple, comenzando con el actual [datetime], agregue 1 segundo 86,399 veces, formatee como una cadena, luego mantenga solo los que suman.

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]

Devuelve una lista de cadenas HH: MM: SS, por ejemplo, f 140-> ["22:59:59","23:58:59","23:59:58"].

Son tres bucles simples a través de las horas, minutos y segundos. Mantenga y formatee todos los valores donde la suma es el número de entrada x.

Pyth - 30 bytes

Toma todos los tiempos posibles y luego los filtros.

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

Test Suite .

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]

Pruébalo en línea!

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%

Produce horas de un solo dígito.

Mathematica, 79 bytes

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

Octava, 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)]')}

Pruébalo en línea!

QBIC , 82 72 bytes

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

Esto llega a un punto desafortunado en QBasic, con la conversión de números, recortar y pretender 0cuando es necesario es realmente costoso.

Salida de muestra:

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

Explicación Escribí una novela al respecto:

:           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 (versión desagradable)

Dado que las reglas no dicen nada acerca de completar en un tiempo determinado (o nada), y nada acerca de ningún duplicado, aquí hay una solución horrible:

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

Raqueta 39 bytes

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

Sin golf:

(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

Pruébalo en línea!

Explicación

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 una cadena vacía adicional como entrada, que supongo no cuenta para el tamaño. Bytecount actualizado (incluido histórico) para agregar dos bytes para la inicialización de la cadena.

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 golf

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
}

Prueba

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

Vista ampliada:

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

Recorre todos los tiempos posibles haciendo un bucle de 86399 a 1,

• convierta el número entero a tiempo dividiendo entre 3600 para obtener el primer dígito
• el segundo dígito tomando el número entero mod 3600 y luego dividiendo por 60
• y el último dígito es el número entero mod 60

Reste los 3 números del valor de entrada para devolver un valor falsey si los tres números se suman al valor de entrada. Si el valor es falsey, envíe el valor.

bash, 78 bytes (usando una utilidad BSD) o 79 bytes (también no BSD)

Esto es un poco más largo que @DigitalTrauma y la agradable solución bash de 71 bytes de @ hvd, pero me gustó la idea de usar números en la base 60; Tengo curiosidad por saber si alguien puede jugar golf un poco más.

Con la utilidad jot estándar BSD:

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

Con la utilidad seq más universalmente disponible:

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

La idea es generar los números del 0 al 83699 y usar dc para convertirlos en base 60. Los "dígitos" en la salida base-60 de dc son números de 2 dígitos del 00 al 59, con espacios que separan los "dígitos", por lo que esto enumera todos los tiempos deseados de 00 00 00 a 23 59 59 en casi el formato necesario.

Sin embargo, si literalmente lleva a cabo eso, los números por debajo de 60 ^ 2 no son números de 3 dígitos en la base 60, por lo que falta el 00 o 00 00 inicial. Por esa razón, en realidad estoy generando los números de 60 ^ 3 a 60 ^ 3 + 83699; esto asegura que todos los números generados tengan exactamente 4 dígitos de largo en la base 60. Esto está bien siempre y cuando eventualmente elimine el primer dígito adicional (01) que no es necesario.

Entonces, una vez que se generan los tiempos deseados, simplemente tomo cada cuádruple de 01 00 00 00 a 01 23 59 59, sumo los últimos tres números y resto el argumento $ 1. Si eso es 0, entonces tomo todo en el cuádruple desde el tercer personaje (tirando el "01"), uso tr para convertir espacios en dos puntos e imprimo el resultado.

PowerShell , 91 97 bytes (incluida la 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,$_}}}

o

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

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

NB: Superado por la versión de @ Briantist: /codegolf//a/105163/6776