以最短的代码在时钟上生成正确时间的获胜。

您是一位经验丰富的时光旅行者，在旅途中会停在许多行星上。每个行星以不同的速度旋转，因此，一天的时间长度不同于我们通常的24小时工作日。结果，行星使用不同小时数的时钟。带有x小时的时钟上的小时与我们的（1、2、3，...，x）排列相似，数字顺时针旋转，x在顶部。

此外，每个行星在一小时内的分钟数不同，在一分钟内的秒数不同。系统将为您提供开始时间和经过的秒数，您必须从中确定结束时间。

输入可以直接从作为参数传递的文件或标准输入中获取。输入的第一行将是您需要处理的时钟数。之后，每个时钟都有三行输入，其中包含以下格式的整数：

x y z
h m s
t

每个字母的含义如下。

x =一天中的小时数（2 <= x <= 99）
y =一小时中的分钟数（2 <= y <= 100）
z =一分钟中的秒数（2 <= z <= 100）
h =起始时间的小时（1 <= h <= x）
m =起始时间的分钟（0 <= m <y）
s =起始时间的秒数（0 <= s <z）
t =经过的秒数

自开始时间起经过t秒后，输出必须是每个时钟的结束时间。您的输出必须格式化为标准时钟时间（HH：MM：SS）。必要时应对数字进行填充，以确保所有数字均为两位数。

测试用例

输入值

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

输出量

04:13:08
02:08:03

输入值

1
14 17 11
12 16 10
1530

输出量

07:03:00

输入值

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

输出量

05:26:10
14:00:00

GolfScript-50个字符

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

通过将值（H / M / S）移动到堆栈（])\）的前面来收集它们。0的小时“下溢”由处理or。零填充用来处理100+`(;，尽管我想0`\+-2>是相同的长度。

Python，142个字符

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个字符

编辑：我设法使数组以前存储在a中以驻留在堆栈上，尽管这样没有太大的改进，但仍需要一些额外的切换。

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

62版本：

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

我敢肯定它可以做得更好，我只是想不出更好的办法。

1：将所有输入组成一个数组，选择第一个元素，将其余所有元素分组为7
个块。a / 13：使用输入中的第一个数字运行该次数的循环。
2：将空数组存储在
3：选择一个7的块并将其扩展为7个单独的数字。
b / 8：循环运行3次，每秒钟，几分钟和几小时一次。
4：将最后两个数字加在一起，第一个迭代是秒和要移动的时间，第二个是分钟和小时，前一个周期有溢出。再次复制结果。
5：将副本除以极限，以产生溢出并将结果移回一格。
6：计算前一个除法的模，以产生一部分结果。
7：将此部分添加到数组中。
9：从堆栈中删除小时溢出以及秒数和分钟数限制。
10：取小时的小时部分，如果为零，则将其替换为小时限制，然后将其放回数组中。
11：对于a中的每个元素，请将“ 0”放在前面，从而转换为字符串，并丢弃除最后2个字符外的所有内容。
12：将数组折叠为以'：'分隔的单个字符串，放置换行符并将包含剩余作业的数组移到堆栈的最前面，从而为下一次迭代做准备。

Ĵ （35分之172） 137 99 107

现在通过所有给定的测试用例。

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；如果我真的很贪笑并且拒绝执行所指示的IO，我将给出的字符数为35。（我仍然对其进行了一些修改； clocks是一个函数，该函数采用一个文件名，该文件名旨在在J中交互使用。）

我肯定希望这在J中要比我看起来容易得多。

编辑：弄清楚如何在J中做更好的输入解析，消除charsub，切换到命令行调用和输出。

编辑2：将中心函数的输入更改为3x3矩阵，消除了许多讨厌的括号，消除了名称

编辑3：处理0点。

说明：

我的J仍然不是很好，并且IO总是很痛苦。因此，这有点愚蠢。

• 动词1 0 0+{.#:{.&{:+{.#.1 0 0-~1&{采用三乘三的矩阵（由输入行组成，最后两个元素是垃圾）
• h / m / s由{得出。（head），实际时间为1＆{（第二个元素），第二个计数为{。＆{:（尾部的头）。
• 该动词使用＃。将时钟时间转换为秒。（请参阅文档。）
• 它添加第二个计数，然后使用＃：获得3元素的答案。
• 通过从基数更改前的小时中减去1，然后在其后加1，来处理0时情况。（带有的两位1 0 0）
• 其余的是输入和输出，这真是肮脏（一如既往）。
• ".;._2(1!:1)3 获取输入的3个“列”矩阵，未填充位置为0。
• ,&}.$~,&3 3&{.&{. 切断输入的第一行，并将其余行整形为Nx3x3。
• 该"2修改的核心动词采取3x3的情况。
• 10 10&#:给出每个数字2个十进制数字，给出一个Nx3x2矩阵。（获得0填充是一种痛苦。）
• ,"2":"0 将数字转换为ASCII（Nx3x2x1）并遍历最后一列，再次将Nx3x2转换为ASCII。
• LF,~"1([,':',])/"2 在每个元素之间插入：并将其附加（Nx7），并为每个元素添加换行符（Nx8）。
• 4(1!:2)~ 打印每一行。

Haskell，159个字符

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

• 编辑：（207-> 200）有时divMod不值得！
• 编辑：（200-> 178）屈服于不使用优雅的foldr方法（该方法适用于具有任意数量组件的时间系统！）
• 编辑：（178-> 164）内联 f
• 编辑：（164-> 158）删除了不必要的括号
• 编辑：（158-> 160）修复了三个以前引入的问题：小时现在又正确了
• 编辑：（160-> 159）挂断了 tail

Ruby，128个字符

从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个必需字符

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个字符）

从作为参数传递的文件中获取输入。

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

和无高尔夫球场：

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

请注意，如果没有信号（美元符号），则为205个字符。

Java，486371个字符

非高尔夫版本：http：//pastebin.com/6LiTdGyi

这将提供与提供的示例相同的输出。

但是我不同意这种行为：一个时钟没有一天中的小时数那么多：它只有一半。

这意味着，如果您将3600秒添加到12:50:12，它应该打印01:50:12，而不是13:50:12（在我们的标准24/60/60系统中）。

我在代码中进行了处理，但在解决方案中对其进行了注释，以使其与示例匹配。当然，如果考虑到这一点，那么除非添加一些AM / PM标记，否则输入时间可能会被认为是不明确的。

但是无论如何，这个难题有一个矛盾之处：如果将00小时替换为x，则将>（x / 2）的小时替换为小时-（x / 2）。

编辑：高尔夫版本：

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

重击-189个字符：

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，229228个字符

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

文件必须作为参数传递到脚本中

取消高尔夫：

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

变更日志：

229-> 228：对小时进行除法时无需设置剩余时间

重击，139个字符

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个字符：

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

我声称与规则相抵触

14 15 20
1 14 0
-580

输出不应该是

14:00:00

但

00:00:00

这就是我的代码产生的。请给我看一个时钟，该时钟在地球上显示24:00:00而不是00:00:00-也许是24:59:59。还是您期望这样的顺序：

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

代替

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

Python 2，137字节

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]]

在线尝试！

仅比其他Python回答短一点，但采用不同的方法到达那里。

取消说明：

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个字符非golfed，空行除外）

对于类似“午夜”的时间，我的打印时间为00:00:00，而不是12:00:00或类似时间。编辑：更改。

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'

还可以抽象一些东西，但是带。它会完全忽略输入文件的第一行，并且通常会对格式不正确的文件大喊大叫。