El código más corto para generar los tiempos correctos en los relojes gana.

Usted es un viajero experimentado en el tiempo y se sabe que se detiene en muchos planetas durante sus viajes. Cada planeta gira a una velocidad diferente y debido a esto, la duración de un día es diferente de nuestro día habitual de 24 horas. Como resultado, los planetas usan relojes con diferentes números de horas. Las horas en un reloj con x horas están dispuestas de manera similar a la nuestra (1, 2, 3, ..., x ) con el número girando en sentido horario yx estando en la parte superior.

Además, cada planeta tiene una cantidad diferente de minutos en una hora y un número diferente de segundos en un minuto. Se le dará un tiempo de inicio y una cantidad de segundos transcurridos a partir de los cuales debe determinar el tiempo de finalización.

La entrada puede tomarse directamente de un archivo pasado como argumento o como entrada estándar. La primera línea de entrada será la cantidad de relojes que necesita procesar. Después de eso, cada reloj tiene tres líneas de entrada que contienen enteros en el siguiente formato:

x y z
h m s
t

El significado de cada letra está abajo.

x = El número de horas en un día (2 <= x <= 99)
y = El número de minutos en una hora (2 <= y <= 100)
z = El número de segundos en un minuto (2 <= z <= 100)
h = La hora del tiempo de inicio (1 <= h <= x)
m = El minuto del tiempo de inicio (0 <= m <y)
s = El segundo del tiempo de inicio (0 <= s <z)
t = El número de segundos que han transcurrido

La salida debe ser la hora de finalización de cada reloj después de que hayan pasado t segundos desde la hora de inicio. Su salida debe estar formateada como la hora estándar del reloj (HH: MM: SS). Los números deben rellenarse, cuando sea necesario, para garantizar que todos los números sean de dos dígitos.

Casos de prueba

Entrada

2
5 20 10
1 10 5
2633
6 25 5
6 0 3
290

Salida

04:13:08
02:08:03

Entrada

1
14 17 11
12 16 10
1530

Salida

07:03:00

Entrada

2
8 40 25
3 1 15
10620
14 15 20
1 14 0
-580

Salida

05:26:10
14:00:00

GolfScript - 50 caracteres

~](;7/{{~+.4$/\4$%])\}3*3<)@\or\+{100+`(;}%':'*n}%

Los valores (H / M / S) se recopilan moviéndolos al frente de la pila ( ])\). La hora 'underflow' en 0 se maneja con or. Se maneja el relleno cero 100+`(;, aunque supongo que 0`\+-2>tiene la misma longitud.

Python, 142 caracteres

R=raw_input
for i in' '*input():x,y,z,h,m,s=map(int,(R()+i+R()).split());t=input()+h*y*z+m*z+s;print'%02d:%02d:%02d'%((t/y/z-1)%x+1,t/z%y,t%z)

GolfScript 62 60 caracteres

Editar: logré que la matriz anteriormente almacenada en un para residir en la pila, requiere un poco de cambio adicional de esa manera, así que no hubo una mejora importante.

~](\7/\{(~+[]\{.5$/@@5$%\+@@+}3*;\;(@or\+{'0'\+-2>}%':'*n@}*

62 versión:

~](\7/\{[]:a;(~{+.4$/\4$%a+:a;}3*;;;a(@or\+{'0'\+-2>}%':'*n@}*
1______a2____3_b4_5___6__7____8__9__10_____11_________12____13

Estoy seguro de que se puede hacer mucho mejor, simplemente no se me ocurre nada mejor.

1: Haga una matriz de todas las entradas, seleccione el primer elemento, agrupe el resto en bloques de 7.
a / 13: Consuma el primer número de la entrada para ejecutar el ciclo esa cantidad de veces.
2: Almacenar una matriz vacía en a.
3: Elija un bloque de 7 y amplíelo a 7 números individuales.
b / 8: ejecuta un bucle 3 veces, una vez por cada segundo, minuto y hora.
4: Agregue los dos últimos números juntos, para la primera iteración que son segundos y tiempo para cambiar, para lo siguiente son minutos y horas con el desbordamiento del ciclo anterior. Haga una segunda copia del resultado.
5: Divida la copia por su límite para producir el desbordamiento y desplazar el resultado un espacio hacia atrás.
6: Calcular el módulo de la división anterior para producir una parte del resultado.
7: Agregue esta parte a la matriz.
9: Elimine el desbordamiento de hora y los límites de segundo y minuto de la pila.
10: Tome la parte de la hora de a, si es cero, reemplácela con el límite de la hora, vuelva a colocarla en la matriz.
11: Para cada elemento en a, coloque '0' al frente, convirtiendo así en cadena, y deseche todo menos los últimos 2 caracteres.
12: Contraiga la matriz en una sola cadena delimitada por ':', coloque una nueva línea y desplace la matriz que contiene los trabajos restantes al frente de la pila, preparándose para la próxima iteración.

J (172/35) 137 99 107

Ahora pasa todos los casos de prueba dados.

4(1!:2)~LF,~"1([,':',])/"2,"2":"0(10 10#:1 0 0+{.#:{.&{:+{.#.1 0 0-~1&{)"2&(,&}.$~,&3 3&{.&{.)".;._2(1!:1)3

172 es todo; 35 es el número de caracteres que daría si fuera realmente presumido y me negara a hacer el IO como se indica. (Todavía lo modifiqué un poco; relojes es una función que toma un nombre de archivo destinado a ser usado interactivamente dentro de J.)

Espero que esto sea mucho más fácil en J de lo que lo veo.

Editar: descubrió cómo hacer un mejor análisis de entrada en J, eliminó el carácter de caracteres, cambió a invocación y salida de línea de comando.

Edición 2: Se modificó la entrada de la función central a la matriz 3x3, se eliminaron muchos paréntesis molestos, se eliminaron los nombres

Edición 3: las 0 en punto manejado.

Explicación:

Mi J todavía no es genial, y IO es un dolor como siempre. Así que partes de esto son una locura.

• El verbo 1 0 0+{.#:{.&{:+{.#.1 0 0-~1&{toma una matriz de tres por tres (que consiste en las líneas de entrada, los dos últimos elementos son basura)
• El h / m / s se obtiene con {. (cabeza), el tiempo real con 1 y {(segundo elemento), y el segundo cuenta con {. & {: (cabeza de cola).
• El verbo usa #. para transformar la hora del reloj a segundos. (Ver documentación).
• Agrega el segundo conteo y luego usa #: para obtener la respuesta de 3 elementos.
• El caso de las 0 en punto se maneja restando 1 de la hora anterior al cambio de base y sumando 1 después. (los dos bits con 1 0 0)
• El resto es entrada y salida, que es realmente sucio (como siempre).
• ".;._2(1!:1)3 obtiene una matriz de 3 'columnas' de la entrada con 0s en posiciones sin llenar.
• ,&}.$~,&3 3&{.&{. corta la primera fila de la entrada y da forma a las filas restantes en Nx3x3.
• El "2modifica el verbo central para tomar los casos 3x3.
• 10 10&#:da 2 dígitos decimales para cada número que da una matriz Nx3x2. (Obtener 0s para el relleno fue un dolor ).
• ,"2":"0 convierte los dígitos a ASCII (Nx3x2x1) y descifra la última columna, dando Nx3x2 nuevamente como ASCII.
• LF,~"1([,':',])/"2 inserta: entre cada elemento y los agrega (Nx7) y agrega un salto de línea por para (Nx8).
• 4(1!:2)~ imprime cada fila.

Haskell, 159 caracteres

v(_:x:y:z:h:m:s:t:r)=(w%x+1)&":"$z%y&":"$1%z&"\n"$v$t:r where w=y*z;(%)=mod.div(t+h*w-w+m*z+s)
v _=""
d&c=tail.(shows(d+100)c++)
main=interact$v.map read.words

• Editar: (207 -> 200) a veces divModno vale la pena!
• Editar: (200 -> 178) sucumbió a no usar el foldrenfoque elegante (¡que funciona para sistemas de tiempo con cualquier número de componentes!)
• Editar: (178 -> 164) en línea f
• Editar: (164 -> 158) eliminó paréntesis innecesarios
• Editar: (158 -> 160) corregido un poco introducido hace tres ediciones: las horas ahora son correctas nuevamente
• Editar: (160 -> 159) perdió una llamada a tail

Ruby, 128 caracteres

Copias descaradamente del python one:

d=$<.read.split.map(&:to_i);d[0].times{|o|x,y,z,h,m,s,t=d[o*7+1,7];t+=z*(y*h+m)+s;puts ["%02d"]*3*':'%[(t/y/z-1)%x+1,t/z%y,t%z]}

Haskell - 219 personajes necesarios

import Text.Printf
(#)=div
(%)=mod
n?d=(n-1)%d+1
e a n=mapM(\_->a)[1..n]
main=readLn>>=(e$do{
 a<-e getLine 3;
 let[x,y,z,h,m,s,t]=map read.words=<<a;
    w=y*z;e=h*w+m*z+s+t::Int
  in printf"%02d:%02d:%02d\n"(e#w?x)(e#z%y)(e%z)})

PHP (241 caracteres)

Toma información de un archivo pasado como argumento.

foreach(array_chunk(array_slice(file($argv[1]),1),3)as$v){list($x,$y,$z)=split(" ",$v[0]);list($h,$m,$s)=split(" ",$v[1]);$e=($v[2]+$s+$z*($m+$h*$y))%($x*$y*$z);$s=$e%$z;$e/=$z;$m=$e%$y;$h=($e/$y)%$x;printf("%02d:%02d:%02d\n",$h?:$x,$m,$s);}

Y sin golfos:

$input = array_chunk(array_slice(file($argv[1]),1),3);
foreach($input as $v){
    list($x,$y,$z)=split(" ",$v[0]);
    list($h,$m,$s)=split(" ",$v[1]);
    $t = $v[2];
    $seconds_in_day = $x * $y * $z;
    $total_elapsed = $t + $s + $m*$z + $h*$y*$z;
    $elapsed = $total_elapsed % $seconds_in_day;

    $sec = $elapsed % $z;
    $elapsed /= $z;

    $min = $elapsed % $y;
    $elapsed /= $y;

    $hours = $elapsed % $x;
    if ($hours == 0) $hours = $x;

    printf("%02d:%02d:%02d\n",$hours,$min,$sec);
}

Y solo para notar, sin sigilos (el signo de dólar), esto llega a 205 caracteres.

Java, 486 371 caracteres

Versión sin golf: http://pastebin.com/6LiTdGyi

Esto proporciona el mismo resultado que en los ejemplos proporcionados.

Pero no estoy de acuerdo con ese comportamiento: un reloj no tiene tantos números como horas en un día: tiene la mitad de ellos.

Lo que significa que si agrega 3600 segundos a 12:50:12, debería imprimir 01:50:12, no 13:50:12 (en nuestro sistema estándar 24/60/60).

Manejé eso en mi código pero lo comenté en mi solución para que coincida con los ejemplos. Por supuesto, si considera esto, los tiempos de entrada podrían considerarse ambiguos a menos que agregue algún marcador AM / PM.

Pero en cualquier caso, el rompecabezas tiene una inconsistencia: si 00 horas deben reemplazarse por x, entonces horas> (x / 2) deben reemplazarse por horas - (x / 2).

Editar: versión de golf:

import java.io.File;import java.util.Scanner;public class U{static int i(Scanner s){return
s.nextInt();}public static void main(String[]g)throws Exception{Scanner s=new Scanner(new File(g[0
]));int n=i(s);while(0!=n--){int J=i(s),K=i(s),L=i(s),P=(i(s)*K*L+i(s)*L+i(s)+i(s))%(J*K*L);System.
out.println(String.format("%02d:%02d:%02d",(0==P/L/K%J)?J:P/L/K%J,P/L%K,P%L));}}}

Bash - 189 caracteres:

read n
for((i=0;i<n;i++));do
read x y z
read h m s
read t
R=$(((s+m*z+h*y*z+t)%(x*y*z)))
H=$((R/y/z))
R=$((R-H*y*z))
M=$((R/z))
printf"%02d:%02d:%02d\n"$((((H-1)%x+x)%x+1))$M$((R-M*z))
done

PHP 229 228 caracteres

<?$v=file($argv[1]);while(++$i<$v[0]*3){list($x,$y,$z)=split(" ",$v[$i++]);list($h,$m,$s)=split(" ",$v[$i++]);$s=($e=($v[$i]+$s+$m*$z+$h*$y*$z)%($x*$y*$z))%$z;$m=($e/=$z)%$y;printf("%02d:%02d:%02d\n",($e/$y)%$x?$e%$x:$x,$m,$s);}

El archivo debe pasarse al script como argumento

Sin golf:

<?php

$v = file($argv[1]); // Automatically break the file into an array by line

while(++$i < $v[0]*3){ // Loop for every three lines
  list($x, $y, $z) = explode(" ", $v[$i++]); // Break apart the first line by space
  list($h, $m, $s) = explode(" ", $v[$i++]); // Break apart the second line

  /*
    Add the starting time to the total number of seconds that have passed
    Divide by total amount of seconds in a day
  */

  $time = ($v[$i] + $s + $m * $z + $h * $y * $z) % ($x * $y * $z);

  $seconds = $time % $z;  // Get the number of seconds
  $minutes = ($time /= $z) % $y; // Remove the end amount of seconds, then get the minutes

  /*
    Remove the end amount of hours
    Determine how many hours there would be
    If the number is zero, then output the max hours
    If the number is not zero, output the amount of hours left
  */

  $hours = ($time / $y) % $x? $e % $x : $x;

  // Display the time in the correct format
  printf("%02d:%02d:%02d\n", $hours, $minutes, $seconds);
}

Registro de cambios:

229 -> 228: no es necesario establecer el tiempo restante mientras se realiza la división por horas

Bash, 139 caracteres

read n
while((n--));do
read x y z;read h m s;read t
((t+=z*(y*h+m)+s,a=(t/y/z-1)%x+1,b=t/z%y,c=t%z))
printf %02d:%02d:%02d\\n $a $b $c
done

Scala 184 caracteres:

object C extends App{val r=new java.util.Scanner(System.in)
def n=r.nextInt
for(j<-1 to n;h=n;m=n;s=n;x=n;y=n;z=n;t=n;d=(x*m+y)*s+z+t){printf("%02d:%02d:%02d\n",d/(m*s)%h,d/s%m,d%s)}
}

En conflicto con las reglas, afirmo, que para

14 15 20
1 14 0
-580

La salida no debería ser

14:00:00

pero

00:00:00

y eso es lo que produce mi código. Por favor, muéstrame un reloj que muestre las 24:00:00 en la Tierra en lugar de las 00:00:00, tal vez las 24:59:59. ¿O esperas la secuencia:

23:59:59
24:00:00
00:00:01

en lugar de

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

Python 2 , 137 bytes

lambda T:["%02d:%02d:%02d"%((s/z/y%x,x)[s%x<1],s/z%y,s%z)for x,y,z,h,m,s,t in[T[i:i+7]for i in range(1,len(T),7)]for s in[s+m*z+h*y*z+t]]

Pruébalo en línea!

Solo un poco más corto que la otra respuesta de Python , pero toma una ruta diferente para llegar allí.

Explicación no golfista:

def f(T):
    # ignore first list element, split list into even chunks of length 7
    for i in range(1, len(T), 7):
        # get variables for sublist
        for x, y, z, h, m, s, t in [T[i:i + 7]]:
            # get total time in seconds, inside a list so that we can use list comprehension
            for s in [s + m*z + h*y*z + t]:
                # split total time into parts
                # seconds: convert seconds to minute, take remainder
                sec = s % z
                # minutes: convert seconds to minutes (discard remainder), convert minutes to hours, take remainder
                min = s / z % y
                # hours: convert seconds to minutes (discard remainder),
                #        convert minutes to hours (discard remainder),
                #        convert hours to days, take remainder
                # if seconds are evenly divisible by total hours, use number of hours in day instead ("midnight")
                hr = (s / z / y % x, x)[s % x < 1]

                print "%02d:%02d:%02d"%(hr, min, sec)

Haskell ( 815 624 caracteres no golfed, líneas en blanco excluidos)

El mío imprime 00:00:00 en lugar de 12:00:00 o similar para los horarios de "medianoche". Editar: cambió eso.

main = readFile "in.txt" >> mapM_ print . times . map (map read . words) . tail . lines

times [] = []
times ([x,y,z]:[h,m,s]:[t]:xs) = Time x y z h m s +++ t : times xs

data Time = Time {x,y,z,h,m,s :: Int}
hr t | h t == 0 = x t | otherwise = h t

instance Show Time where show t = pad2 (hr t) ++ ':':pad2 (m t) ++ ':':pad2 (s t)

pad2 x | x < 10 = '0':show x | otherwise = show x

t +++ ss | ss < 0  = t +++ (ss + x'*y'*z') | otherwise = Time x' y' z' h' m' s'
  where (x',y',z') = (x t, y t, z t)
        (ms, s') = (s t + ss) `quotRem` z'
        (hs, m') = (m t + ms) `quotRem` y'
        (_,  h') = (h t + hs) `quotRem` x'

Podría haber abstraído algunas cosas más, pero w / e. Ignora por completo la primera línea del archivo de entrada y, en general, le pide archivos con formato incorrecto.