Der kürzeste Code, um die richtigen Uhrzeiten zu generieren, gewinnt.

Sie sind ein erfahrener Zeitreisender und es ist bekannt, dass Sie auf Ihren Reisen auf vielen Planeten Halt machen. Jeder Planet dreht sich mit einer anderen Geschwindigkeit und aus diesem Grund ist die Länge eines Tages anders als unser üblicher 24-Stunden-Tag. Infolgedessen verwenden die Planeten Uhren mit unterschiedlichen Stundenzahlen. Die Stunden auf einer Uhr mit x Stunden sind ähnlich wie bei unserer (1, 2, 3, ..., x ) angeordnet, wobei sich die Zahl im Uhrzeigersinn dreht und x oben steht.

Außerdem hat jeder Planet eine andere Anzahl von Minuten pro Stunde und eine andere Anzahl von Sekunden pro Minute. Sie erhalten eine Startzeit und eine Anzahl von Sekunden, aus denen Sie die Endzeit bestimmen müssen.

Die Eingabe kann direkt aus einer als Argument übergebenen Datei oder als Standardeingabe erfolgen. Die erste Eingabezeile gibt die Anzahl der zu verarbeitenden Takte an. Danach hat jede Uhr drei Eingabezeilen, die Ganzzahlen im folgenden Format enthalten:

x y z
h m s
t

Die Bedeutung der einzelnen Buchstaben finden Sie weiter unten.

x = Die Anzahl der Stunden pro Tag (2 <= x <= 99)
y = Die Anzahl der Minuten pro Stunde (2 <= y <= 100)
z = Die Anzahl der Sekunden pro Minute (2 <= z <= 100)
h = Die Stunde der Startzeit (1 <= h <= x)
m = Die Minute der Startzeit (0 <= m <y)
s = Die Sekunde der Startzeit (0 <= s) <z)
t = Die Anzahl der Sekunden, die vergangen sind

Die Ausgabe muss die Endzeit für jede Uhr sein, nachdem t Sekunden seit der Startzeit verstrichen sind. Ihre Ausgabe muss als Standarduhrzeit formatiert sein (HH: MM: SS). Zahlen sollten bei Bedarf aufgefüllt werden, um sicherzustellen, dass alle Zahlen zweistellig sind.

Testfälle

Eingang

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

Ausgabe

04:13:08
02:08:03

Eingang

1
14 17 11
12 16 10
1530

Ausgabe

07:03:00

Eingang

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

Ausgabe

05:26:10
14:00:00

GolfScript - 50 Zeichen

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

Die Werte (H / M / S) werden erfasst, indem sie an die Vorderseite des Stapels verschoben werden ( ])\). Die Stunde 'underflow' bei 0 wird mit behandelt or. Null-Polsterung wird behandelt 100+`(;, obwohl ich nehme an, dass 0`\+-2>es die gleiche Länge ist.

Python, 142 Zeichen

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 Zeichen

Bearbeiten: Ich habe es geschafft, das Array, das zuvor in a gespeichert war, auf dem Stack zu speichern. Auf diese Weise ist ein zusätzlicher Wechsel erforderlich, aber keine wesentliche Verbesserung.

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

62 version:

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

Ich bin mir sicher, dass es viel besser geht, ich hätte mir nichts Besseres vorstellen können.

1: Erstellen Sie ein Array aller Eingaben, wählen Sie das erste Element aus und gruppieren Sie den Rest in 7er-Blöcke.
A / 13: Verwenden Sie die erste Zahl aus der Eingabe, um die Schleife so oft auszuführen.
2: Speichern Sie ein leeres Array in a.
3: Wählen Sie einen 7er-Block und erweitern Sie ihn auf 7 einzelne Zahlen.
b / 8: Führen Sie eine Schleife dreimal aus, und zwar einmal pro Sekunde, Minute und Stunde.
4: Addieren Sie die letzten beiden Zahlen für die erste Iteration, die Sekunden und die zu verschiebende Zeit ist, für die folgende Iteration sind es Minuten und Stunden mit dem Überlauf aus dem vorherigen Zyklus. Machen Sie eine zweite Kopie des Ergebnisses.
5: Teilen Sie die Kopie durch das Limit, um den Überlauf zu erzeugen und das Ergebnis um ein Leerzeichen nach hinten zu verschieben.
6: Berechnen Sie das Modulo der vorherigen Division, um einen Teil des Ergebnisses zu erhalten.
7: Fügen Sie diesen Teil dem Array a hinzu.
9: Entfernen Sie den Stundenüberlauf sowie die Sekunden- und Minutenbegrenzung vom Stapel.
10: Nehmen Sie den Stundenanteil von a. Wenn er Null ist, ersetzen Sie ihn durch das Stundenlimit, und legen Sie ihn wieder in das Array ein.
11: Setzen Sie für jedes Element in a '0' voran und konvertieren Sie es in einen String. Werfen Sie dann alles außer den letzten 2 Zeichen weg.
12: Reduzieren Sie das Array in eine einzelne Zeichenfolge, die durch ':' begrenzt ist, platzieren Sie eine neue Zeile und verschieben Sie das Array mit den verbleibenden Jobs an den Anfang des Stapels, um die nächste Iteration vorzubereiten.

J (172/35) 137 99 107

Besteht nun alle gegebenen Testfälle.

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 ist das Ganze; 35 ist die Anzahl der Zeichen, die ich vergeben würde, wenn ich wirklich auf dem Laufenden wäre und es ablehnen würde, die E / A wie angegeben durchzuführen. (Ich habe es noch ein wenig modifiziert; clocks ist eine Funktion, die einen Dateinamen verwendet, der für die interaktive Verwendung in J gedacht ist.)

Ich hoffe, dass dies in J viel einfacher ist, als ich es aussehen lassen würde.

Bearbeiten: Herausgefunden, wie man das Parsen von Eingaben in J verbessert, Charsub beseitigt, auf Kommandozeilenaufruf und Ausgabe umgestellt.

Edit 2: Eingabe der Zentralfunktion in 3x3 Matrix geändert, viele lästige Klammern entfernt, Namen entfernt

Edit 3: 0-Uhr gehandhabt.

Erläuterung:

Mein J ist immer noch nicht großartig und IO ist ein Schmerz wie immer. Also sind Teile davon verrückt.

• Das Verb 1 0 0+{.#:{.&{:+{.#.1 0 0-~1&{nimmt eine drei mal drei Matrix (bestehend aus den Eingabezeilen, die letzten beiden Elemente sind Müll)
• Die h / m / s werden mit {bekommen. (head), die aktuelle Zeit mit 1 & {(zweites Element) und die zweite Zeit mit {. & {: (head of tail).
• Das Verb benutzt #. um die Uhrzeit in Sekunden umzuwandeln. (Siehe Dokumentation.)
• Es addiert die zweite Zählung und verwendet dann #:, um die 3-Element-Antwort zu erhalten.
• Der 0-Uhr-Fall wird durch Subtrahieren von 1 von der Stunde vor dem Basiswechsel und Addieren von 1 zurück nach behandelt. (die zwei Bits mit 1 0 0)
• Der Rest ist Input und Output, was (wie immer) sehr schmuddelig ist.
• ".;._2(1!:1)3 Ruft eine 3-Spalten-Matrix der Eingabe mit 0en an nicht ausgefüllten Positionen ab.
• ,&}.$~,&3 3&{.&{. Schneidet die erste Zeile von der Eingabe ab und formt die verbleibenden Zeilen in Nx3x3.
• Das "2ändert das Zentralverb, um die 3x3-Fälle zu übernehmen.
• 10 10&#:Gibt 2 Dezimalstellen für jede Zahl aus, die eine Nx3x2-Matrix ergibt. (Nullen für das Auffüllen zu bekommen, war ein Schmerz .)
• ,"2":"0 konvertiert die Ziffern in ASCII (Nx3x2x1) und wandelt die letzte Spalte um, wobei Nx3x2 erneut als ASCII angegeben wird.
• LF,~"1([,':',])/"2 fügt: zwischen jedes Element ein und hängt es an (Nx7) und fügt einen Zeilenvorschub pro für (Nx8) hinzu.
• 4(1!:2)~ druckt jede Zeile.

Haskell, 159 Zeichen

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) divModist es manchmal nicht wert!
• Edit: (200 -> 178) hat es nicht geschafft, den eleganten foldrAnsatz zu verwenden (der für Zeitsysteme mit einer beliebigen Anzahl von Komponenten funktioniert!)
• Bearbeiten: (178 -> 164) Inline f
• Bearbeiten: (164 -> 158) unnötige Klammern entfernt
• Edit: (158 -> 160) korrigiert ein bisschen vor drei Änderungen eingeführt: Stunden sind jetzt wieder korrekt
• Bearbeiten: (160 -> 159) hat einen Anruf an abgebrochen tail

Rubin, 128 Zeichen

Schamlos kopiert von der 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 notwendige Zeichen

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

Übernimmt die Eingabe aus einer Datei, die als Argument übergeben wird.

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

Und ungolfed:

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

Und nur zur Erinnerung, ohne Siegel (das Dollarzeichen) ergibt dies 205 Zeichen.

Java, 486 371 Zeichen

Ungolfed-Version: http://pastebin.com/6LiTdGyi

Dies ergibt die gleiche Ausgabe wie in den bereitgestellten Beispielen.

Aber ich bin nicht einverstanden mit diesem Verhalten: Eine Uhr hat nicht so viele Zahlen wie Stunden an einem Tag: Sie hat die Hälfte davon.

Das heißt, wenn Sie 3600 Sekunden zu 12:50:12 addieren, sollte 01:50:12 und nicht 13:50:12 gedruckt werden (in unserem Standardsystem 24/60/60).

Ich habe das in meinem Code behandelt, es aber in meiner Lösung auskommentiert, damit es mit den Beispielen übereinstimmt. Wenn Sie dies berücksichtigen, können die Eingabezeiten natürlich mehrdeutig sein, es sei denn, Sie fügen AM / PM-Marker hinzu.

In jedem Fall hat das Rätsel eine Inkonsistenz: Wenn 00 Stunden durch x ersetzt werden sollen, sollten Stunden> (x / 2) durch Stunden - (x / 2) ersetzt werden.

Edit: Golf Version:

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

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 Zeichen

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

Die Datei muss als Argument an das Skript übergeben werden

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

Änderungsprotokoll:

229 -> 228: Es muss keine verbleibende Zeit eingestellt werden, während die Stunden geteilt werden

Bash, 139 Zeichen

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

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

Im Widerspruch zu den Regeln behaupte ich, dass z

14 15 20
1 14 0
-580

Die Ausgabe sollte nicht sein

14:00:00

aber

00:00:00

und das ist, was mein Code erzeugt. Bitte zeigen Sie mir eine Uhr, die 24:00:00 statt 00:00:00 zeigt - vielleicht 24:59:59. Oder erwarten Sie die Reihenfolge:

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

anstatt

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

Probieren Sie es online!

Nur etwas kürzer als die andere Python-Antwort , nimmt aber einen anderen Weg, um dorthin zu gelangen.

Ungolfed Erklärung:

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 Zeichen ohne Golf, ohne Leerzeilen)

Mine druckt 00:00:00 anstelle von 12:00:00 oder ähnlich für "Mitternacht" -ähnliche Zeiten. Bearbeiten: hat das geändert.

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'

Hätte ein paar Dinge mehr abstrahieren können, aber w / e. Es ignoriert die erste Zeile der Eingabedatei vollständig und schreit Sie im Allgemeinen nach falsch formatierten Dateien an.