O código mais curto para gerar os horários corretos nos relógios vence.

Você é um viajante experiente no tempo e sabe-se que para em muitos planetas durante seus diários. Cada planeta gira a uma taxa diferente e, por isso, a duração de um dia é diferente da nossa habitual 24 horas por dia. Como resultado, os planetas usam relógios com diferentes números de horas. As horas em um relógio com x horas são organizadas de maneira semelhante à nossa (1, 2, 3, ..., x ), com o número girando no sentido horário ex x no topo.

Além disso, cada planeta tem uma quantidade diferente de minutos em uma hora e um número diferente de segundos em um minuto. Você receberá um horário de início e um número de segundos decorridos a partir dos quais deverá determinar o horário de término.

A entrada pode ser obtida diretamente de um arquivo passado como argumento ou como entrada padrão. A primeira linha de entrada será o número de relógios que você precisa processar. Depois disso, cada relógio possui três linhas de entrada que contêm números inteiros no seguinte formato:

x y z
h m s
t

O significado de cada letra está abaixo.

x = O número de horas em um dia (2 <= x <= 99)
y = O número de minutos em uma hora (2 <= y <= 100)
z = O número de segundos em um minuto (2 <= z <= 100)
h = A hora do horário de início (1 <= h <= x)
m = O minuto do horário de início (0 <= m <y)
s = O segundo do horário de início (0 <= s <z)
t = O número de segundos decorridos

A saída deve ser o horário final de cada relógio após t segundos após o horário de início. Sua saída deve ser formatada como hora padrão do relógio (HH: MM: SS). Os números devem ser preenchidos, quando necessário, para garantir que todos os números tenham dois dígitos.

Casos de teste

Entrada

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

Resultado

04:13:08
02:08:03

Entrada

1
14 17 11
12 16 10
1530

Resultado

07:03:00

Entrada

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

Resultado

05:26:10
14:00:00

GolfScript - 50 caracteres

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

Os valores (H / M / S) são coletados movendo-os para a frente da pilha ( ])\). A hora 'underflow' em 0 é tratada com or. O preenchimento zero é tratado 100+`(;, embora eu suponha que 0`\+-2>tenha o mesmo comprimento.

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

Edit: Eu consegui obter o array armazenado anteriormente em um para residir na pilha, é preciso um pouco de alternância extra dessa maneira, embora nenhuma grande melhoria.

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

62 versão:

~](\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

Tenho certeza de que isso pode ser feito muito melhor, simplesmente não consegui pensar em nada melhor.

1: Faça uma matriz de todas as entradas, selecione o primeiro elemento, agrupe o restante em blocos de 7.
a / 13: Consuma o primeiro número da entrada para executar o loop esse número de vezes.
2: Armazene uma matriz vazia em a.
3: Escolha um bloco de 7 e expanda-o para 7 números individuais.
b / 8: execute um loop 3 vezes, uma vez para cada um dos segundos, minutos e horas.
4: Adicione os dois últimos números juntos, para a primeira iteração que é segundos e hora de mudar, e para o seguinte, são minutos e horas com o estouro do ciclo anterior. Faça uma segunda cópia do resultado.
5: Divida a cópia pelo seu limite para produzir o estouro e mude o resultado para um espaço.
6: Calcule o módulo da divisão anterior para produzir uma parte do resultado.
7: Adicione esta parte à matriz a.
9: Remova o excesso de horas e os limites de segundo e minuto da pilha.
10: Pegue a parte da hora de a, se for zero, substitua-o pelo limite de horas, coloque-o novamente na matriz.
11: Para cada elemento em a, coloque '0' na frente, convertendo em string e jogando fora tudo, exceto os últimos 2 caracteres.
12: Recolha a matriz em uma única sequência delimitada por ':', coloque uma nova linha e mude a matriz que contém os trabalhos restantes para a frente da pilha, preparando-se para a próxima iteração.

J (172/35) 137 99 107

Agora passa todos os casos de teste fornecidos.

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 é a coisa toda; 35 é o número de caracteres que eu daria se fosse realmente esnobe e se recusasse a fazer o pedido de informação conforme indicado. (Eu ainda o modifiquei um pouco; clocks é uma função que usa um nome de arquivo que deve ser usado interativamente dentro de J.)

Espero que isso seja muito mais fácil em J do que pareço.

Edit: Descobri como fazer uma análise de entrada melhor em J, eliminado charsub, alternado para invocação e saída da linha de comando.

Edit 2: Entrada alterada da função central para a matriz 3x3, eliminado muitos parênteses traquinas, nomes eliminados

Editar 3: 0 em ponto.

Explicação:

Meu J ainda não é ótimo, e IO é uma dor como sempre. Então, partes disso são malucas.

• O verbo 1 0 0+{.#:{.&{:+{.#.1 0 0-~1&{usa uma matriz três por três (que consiste nas linhas de entrada, os dois últimos elementos são lixo)
• O h / m / s é obtido com {. (cabeça), o tempo real com 1 & {(segundo elemento) e a segunda contagem com {. & {: (cabeça da cauda).
• O verbo usa #. para transformar o tempo do relógio em segundos. (Veja a documentação.)
• Adiciona a segunda contagem e depois usa #: para obter a resposta de 3 elementos.
• O caso das 0 horas é tratado subtraindo 1 da hora anterior à alteração da base e adicionando 1 depois. (os dois bits com 1 0 0)
• O resto é entrada e saída, o que é realmente sujo (como sempre).
• ".;._2(1!:1)3 obtém uma matriz de 3 'colunas' da entrada com 0s em posições não preenchidas.
• ,&}.$~,&3 3&{.&{. corta a primeira linha da entrada e forma as linhas restantes em Nx3x3.
• O "2modifica o verbo central para receber os casos 3x3.
• 10 10&#:fornece 2 dígitos decimais para cada número, fornecendo uma matriz Nx3x2. (Obter 0s para preenchimento foi uma dor .)
• ,"2":"0 converte os dígitos em ASCII (Nx3x2x1) e percorre a última coluna, fornecendo Nx3x2 novamente como ASCII.
• LF,~"1([,':',])/"2 insere: entre cada elemento e os anexa (Nx7) e adiciona um avanço de linha por (Nx8).
• 4(1!:2)~ imprime cada linha.

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

• Edit: (207 -> 200) às vezes divModnão vale a pena!
• Edit: (200 -> 178) sucumbiu a não usar a foldrabordagem elegante (que funciona para sistemas de tempo com qualquer número de componentes!)
• Editar: (178 -> 164) embutido f
• Editar: (164 -> 158) removeu parênteses desnecessários
• Edit: (158 -> 160) corrigido um pouco, introduzido há três edições: as horas agora estão corretas novamente
• Editar: (160 -> 159) encerrou uma chamada para tail

Ruby, 128 caracteres

Copia descaradamente do python:

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 caracteres necessários

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)

Recebe entrada de um arquivo passado 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);}

E não destruído:

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

E apenas para observar, sem sigilos (o cifrão), isso sai para 205 caracteres.

Java, 486 371 caracteres

Versão ungolfed: http://pastebin.com/6LiTdGyi

Isso fornece a mesma saída que nos exemplos fornecidos.

Mas eu discordo desse comportamento: um relógio não tem tantos números quanto horas há no dia: ele tem metade deles.

Isso significa que, se você adicionar 3600 segundos a 12:50:12, deverá imprimir 01:50:12, e não 13:50:12 (em nosso sistema 24/60/60 padrão).

Eu lidei com isso no meu código, mas comentei na minha solução para que ele correspondesse aos exemplos. Obviamente, se você considerar isso, os tempos de entrada poderão ser considerados ambíguos, a menos que você adicione algum marcador AM / PM.

Mas, em qualquer caso, o quebra-cabeça tem uma inconsistência: se 00 horas devem ser substituídas por x, horas> (x / 2) devem ser substituídas por horas - (x / 2).

Editar: Versão Golfed:

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

O arquivo deve ser passado para o script como argumento

Ungolfed:

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

Changelog:

229 -> 228: Não é necessário definir o tempo restante durante a divisão nas 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)}
}

Em conflito com as regras, eu afirmo, que para

14 15 20
1 14 0
-580

A saída não deve ser

14:00:00

mas

00:00:00

e é isso que meu código produz. Mostre-me um relógio que exibe 24:00:00 na Terra em vez de 00:00:00 - talvez 24:59:59. Ou você espera a sequência:

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

ao invés 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]]

Experimente online!

Apenas um pouco menor que o outra resposta do Python , mas segue uma rota diferente para chegar lá.

Explicação Ungolfed:

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 não-golfe, linhas em branco excluídas)

O meu imprime 00:00:00 em vez de 12:00:00 ou similar para horários semelhantes à "meia-noite". Edit: mudou isso.

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'

Poderia ter abstraído mais algumas coisas, mas w / e. Ele ignora completamente a primeira linha do arquivo de entrada e geralmente grita com você por arquivos formatados incorretamente.