Vince il codice più breve per generare i tempi corretti sugli orologi.

Sei un viaggiatore del tempo esperto e sei conosciuto per fermarti su molti pianeti durante i tuoi viaggi. Ogni pianeta ruota a una velocità diversa e per questo la durata di un giorno è diversa dalla nostra solita giornata di 24 ore. Di conseguenza, i pianeti usano orologi con diversi numeri di ore. Le ore su un orologio con x ore sono disposte in modo simile al nostro (1, 2, 3, ..., x ) con il numero che ruota in senso orario e che x è in alto.

Inoltre, ogni pianeta ha una diversa quantità di minuti in un'ora e un diverso numero di secondi in un minuto. Ti verrà dato un orario di inizio e un numero di secondi trascorsi da cui devi determinare l'orario di fine.

L'input può essere preso direttamente da un file passato come argomento o come input standard. La prima riga di input sarà il numero di clock che è necessario elaborare. Successivamente, ogni orologio ha tre righe di input che contengono numeri interi nel seguente formato:

x y z
h m s
t

Il significato di ogni lettera è di seguito.

x = Il numero di ore in un giorno (2 <= x <= 99)
y = Il numero di minuti in un'ora (2 <= y <= 100)
z = Il numero di secondi in un minuto (2 <= z <= 100)
h = L'ora dell'ora di inizio (1 <= h <= x)
m = Il minuto dell'ora di inizio (0 <= m <y)
s = Il secondo dell'ora di inizio (0 <= s <z)
t = Il numero di secondi trascorsi

L'uscita deve essere l'ora di fine di ciascun orologio dopo che sono trascorsi t secondi dall'ora di inizio. L'output deve essere formattato come orario standard (HH: MM: SS). I numeri devono essere riempiti, se necessario, per garantire che tutti i numeri siano a due cifre.

Casi test

Ingresso

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

Produzione

04:13:08
02:08:03

Ingresso

1
14 17 11
12 16 10
1530

Produzione

07:03:00

Ingresso

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

Produzione

05:26:10
14:00:00

GolfScript - 50 caratteri

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

I valori (H / M / S) vengono raccolti spostandoli in primo piano nella pila ( ])\). L'ora 'underflow' su 0 viene gestita con or. L'imbottitura Zero viene gestita 100+`(;, anche se suppongo 0`\+-2>abbia la stessa lunghezza.

Python, 142 caratteri

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 caratteri

Modifica: sono riuscito a ottenere l'array precedentemente memorizzato in un per risiedere nello stack, ci vuole un po 'di commutazione in più in quel modo anche se quindi nessun miglioramento significativo.

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

62 versione:

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

Sono sicuro che può essere fatto molto meglio, non riuscivo a pensare a niente di meglio.

1: Crea un array di tutti gli input, scegli il primo elemento, raggruppa il resto in blocchi di 7.
a / 13: utilizza il primo numero dall'input per eseguire il ciclo quel numero di volte.
2: Memorizza un array vuoto in a.
3: Scegli un blocco di 7 ed espanderlo a 7 numeri individuali.
b / 8: eseguire un ciclo 3 volte, una volta per ciascuno di secondi, minuti e ore.
4: sommare gli ultimi due numeri insieme, per la prima iterazione che è secondi e tempi di spostamento, per i seguenti sono minuti e ora con l'overflow del ciclo precedente. Crea una seconda copia del risultato.
5: Dividi la copia per il limite per produrre l'overflow e spostare il risultato indietro di uno spazio.
6: calcola il modulo della divisione precedente per produrre una parte del risultato.
7: aggiungere questa parte all'array.
9: rimuove l'overflow delle ore e i limiti dei secondi e dei minuti dalla pila.
10: prendi la parte oraria di a, se è zero sostituiscila con il limite orario, rimettila nell'array.
11: Per ogni elemento in a, posiziona '0' in primo piano, convertendolo in stringa e butta via tutto tranne gli ultimi 2 caratteri.
12: Comprimi l'array in una singola stringa delimitata da ':', posiziona una nuova riga e sposta l'array contenente i lavori rimanenti in primo piano nello stack, preparandoti così alla successiva iterazione.

J (172/35) 137 99 107

Ora passa tutti i casi di test forniti.

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 è il tutto; 35 è il numero di personaggi che darei se fossi davvero ficcanaso e mi rifiutassi di fare l'IO come indicato. (L'ho ancora modificato un po '; clocks è una funzione che prende un nome file che deve essere usato in modo interattivo all'interno di J.)

Spero che questo sia molto più facile in J di quanto non faccia sembrare.

Modifica: capito come eseguire un migliore analisi dell'input in J, eliminazione di charsub, passaggio a invocazione e output da riga di comando.

Modifica 2: modificato l'input della funzione centrale nella matrice 3x3, eliminato molte fastidiose parentesi, eliminato i nomi

Modifica 3: 0 in punto gestito.

Spiegazione:

La mia J non è ancora eccezionale e IO è un dolore come sempre. Quindi pezzi di questo sono pazzi.

• Il verbo 1 0 0+{.#:{.&{:+{.#.1 0 0-~1&{prende una matrice tre per tre (costituito dalle linee di input, gli ultimi due elementi sono spazzatura)
• L'h / m / s è ottenuto con {. (testa), il tempo effettivo con 1 & {(secondo elemento) e il secondo conteggio con {. & {: (testa della coda).
• Il verbo usa #. per trasformare il tempo in secondi. (Vedi la documentazione.)
• Aggiunge il secondo conteggio e quindi usa #: per ottenere la risposta a 3 elementi.
• La cassa delle 0 viene gestita sottraendo 1 dall'ora prima della modifica della base e aggiungendo 1 indietro dopo. (i due bit con 1 0 0)
• Il resto è input e output, che è davvero sporco (come sempre).
• ".;._2(1!:1)3 ottiene una matrice 3 'colonna' dell'input con 0s in posizioni non riempite.
• ,&}.$~,&3 3&{.&{. taglia la prima riga dall'input e modella le righe rimanenti in Nx3x3.
• Le "2modifica il verbo centrale a prendere i 3x3 casi.
• 10 10&#:fornisce 2 cifre decimali per ogni numero dando una matrice Nx3x2. (Ottenere 0s per il riempimento è stato un dolore .)
• ,"2":"0 converte le cifre in ASCII (Nx3x2x1) e modifica l'ultima colonna, dando nuovamente Nx3x2 come ASCII.
• LF,~"1([,':',])/"2 inserisce: tra ogni elemento e li aggiunge (Nx7) e aggiunge un avanzamento riga per (Nx8).
• 4(1!:2)~ stampa ogni riga.

Haskell, 159 caratteri

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

• Modifica: (207 -> 200) a volte divModnon ne vale la pena!
• Modifica: (200 -> 178) ha ceduto al non utilizzo dell'approccio elegante foldr(che funziona per i sistemi temporali con un numero qualsiasi di componenti!)
• Modifica: (178 -> 164) in linea f
• Modifica: (164 -> 158) ha rimosso le parentesi non necessarie
• Modifica: (158 -> 160) corretto un po 'introdotto tre modifiche fa: ora le ore sono di nuovo corrette
• Modifica: (160 -> 159) ha lasciato cadere una chiamata a tail

Rubino, 128 caratteri

Copie spudoratamente da quella di 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 caratteri necessari

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

Accetta l'input da un file passato come argomento.

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 non golfato:

$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 solo per notare, senza sigilli (il simbolo del dollaro), questo arriva a 205 caratteri.

Java, 486 371 caratteri

Versione non golfata: http://pastebin.com/6LiTdGyi

Questo fornisce lo stesso output degli esempi forniti.

Ma non sono d'accordo su quel comportamento: un orologio non ha tanti numeri quante sono le ore al giorno: ne ha la metà.

Ciò significa che se aggiungi 3600 secondi a 12:50:12, dovrebbe essere stampato 01:50:12, non 13:50:12 (nel nostro sistema standard 24/60/60).

L'ho gestito nel mio codice ma l'ho commentato nella mia soluzione affinché corrisponda agli esempi. Naturalmente se lo consideri, i tempi di input potrebbero essere considerati ambigui a meno che tu non aggiunga un marcatore AM / PM.

Ma in ogni caso, il puzzle ha un'incoerenza: se 00 ore dovrebbero essere sostituite da x, allora le ore> (x / 2) dovrebbero essere sostituite da ore - (x / 2).

Modifica: versione golfata:

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 caratteri:

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 caratteri

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

Il file deve essere passato allo script come argomento

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: Non è necessario impostare il tempo rimanente durante l'esecuzione della divisione sulle ore

Bash, 139 personaggi

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 caratteri:

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

In conflitto con le regole, pretendo, che per

14 15 20
1 14 0
-580

L'output non dovrebbe essere

14:00:00

ma

00:00:00

ed è quello che produce il mio codice. Per favore, mostrami un orologio che mostra 24:00:00 sulla terra invece di 00:00:00 - forse 24:59:59. O ti aspetti la sequenza:

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

invece di

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

Python 2 , 137 byte

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

Provalo online!

Solo leggermente più breve dell'altra risposta di Python , ma prende una strada diversa per arrivarci.

Spiegazione non golfata:

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 caratteri non golfed, escluse le righe vuote)

Il mio stampa 00:00:00 anziché 12:00:00 o simile per volte simili a "mezzanotte". Modifica: cambiato quello.

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'

Avrei potuto sottrarre alcune cose in più, ma w / e. Ignora completamente la prima riga del file di input e generalmente ti urla per file formattati in modo errato.