Sumas de tiempo de 24 horas.

21

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.

Noah L
fuente
3
¡Bienvenido a Programming Puzzles & Code Golf! Si al enchufarlo quiere decir que forma parte del código fuente, eso generalmente no está permitido. En general, es una buena idea mantener esos valores predeterminados. ¿Tenemos que mostrar los resultados como cadenas? Si es así, ¿qué formatos están permitidos?
Dennis
¿Se garantiza que el número de entrada sea positivo? ¿Habrá al menos una solución?
xnor
He editado un poco la pregunta para aclarar / responder algunas cosas. Si su intención fue diferente a mis cambios, no dude en editarlo para que coincida con eso.
Geobits
1
Solo hice eso porque es la forma habitual en que veo los tiempos dados (en el mundo real). Nadie dice nunca que sea 13: 4: 7, pero 5:10:30 es casi siempre aceptable. No tengo ningún problema con que se cambie.
Geobits
3
"Especifique en qué parte de su código se encuentra el valor de entrada". - La convención sobre PPCG para tomar entrada está usando argumentos, así como algunas otras opciones. Ver Predeterminado para Code Golf: Métodos de entrada / salida en Meta.
user2428118

Respuestas:

8

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.
Sherlock9
fuente
8

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 .

Trauma digital
fuente
1
printfEs costoso aquí. Al tacercarse al formato correcto y arreglarlo para que ((t-$1))funcione, puede for t in {0..23}+{00..59}+{00..59};{((${t//+0/+}-$1))||echo ${t//+/:};}
reducirlo
@hvd Buen golf - ¡gracias!
Trauma digital
6

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.

Sean
fuente
4

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!

Dennis
fuente
4

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.

briantista
fuente
FYI: Puede reemplazar 10000000con 1e7lpara guardar 4 bytes ... o incluso 1e7para un byte adicional (creo; tuve que incluir el Lpara el beneficio del parámetro; pero sospecha que su enfoque evita esa necesidad.
JohnLBevan
1
@JohnLBevan gracias! Luché 1e7durante al menos 30 minutos, y fue el Lpostfix el que me perdí; Lo olvidé y no pude encontrar una manera de llegar a int que fuera más corta que la constante. ¿Quién decidió que a [timespan]interprete un [int]as como ticks y un [double]as days de todos modos? El iexbit es bastante brillante, aunque hace que todo esto sea demasiado lento.
briantist
1
Sin preocupaciones; También tuve algo de ayuda en eso;): stackoverflow.com/q/41408902/361842
JohnLBevan
1
@JohnLBevan ¡Literalmente acabo de ver esta pregunta antes del comentario donde la vinculaste ! Agradable.
briantist
1
También el iextruco fue adaptado de un consejo aquí: codegolf.stackexchange.com/a/746/6776
JohnLBevan
3

Haskell, 77 bytes

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

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.

nimi
fuente
2

Pyth - 30 bytes

Toma todos los tiempos posibles y luego los filtros.

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

Test Suite .

Maltysen
fuente
2

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.

Neil
fuente
2

Mathematica, 79 bytes

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

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!

rahnema1
fuente
1

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 :-)
Steenbergh
fuente
QBIC parece interesante. ¿Lo creaste solo para # code-golf? :)
wasatchwizard
@wasatchwizard Sí :-)
steenbergh 01 de
1

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}}
JohnLBevan
fuente
1
No puedo encontrar la meta publicación relevante, pero estoy bastante seguro de que una presentación debe detenerse para que sea válida, a menos que el desafío lo especifique
Sefa
Gracias @Sefa ... si ese es el caso, no puedo encontrar una buena manera de hacer que mi desagradable versión funcione en menos caracteres que la versión limpia de Briantist ... Tentado a eliminar esta respuesta, pero estoy un poco orgulloso de cómo es malo;)
JohnLBevan
0

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
rnso
fuente
0

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
Luis Mendo
fuente
0

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:",""))(""))

usuario2428118
fuente
Si necesita inicializar una cadena para vaciarla, la inicialización debe contarse
edc65
@ edc65 Hecho. ···
usuario2428118
0

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>

edc65
fuente
0

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.

Grax32
fuente
0

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.

Mitchell Spector
fuente
0

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

JohnLBevan
fuente