Wygrywa najkrótszy kod do wygenerowania prawidłowego czasu na zegarze.

Jesteś wytrawnym podróżnikiem w czasie i znane jest z zatrzymywania się na wielu planetach podczas podróży. Każda planeta obraca się w innym tempie iz tego powodu długość dnia jest inna niż nasz zwykły 24-godzinny dzień. W rezultacie planety używają zegarów o różnej liczbie godzin. Godziny na zegarze z x godzinami są ułożone podobnie do naszych (1, 2, 3, ..., x ), przy czym liczba obraca się zgodnie z ruchem wskazówek zegara, a x jest na górze.

Ponadto każda planeta ma inną liczbę minut na godzinę i inną liczbę sekund na minutę. Otrzymasz czas rozpoczęcia i liczbę upływających sekund, od których musisz określić czas zakończenia.

Dane wejściowe można pobierać bezpośrednio z pliku przekazanego jako argument lub jako dane standardowe. Pierwszym wierszem wprowadzania będzie liczba zegarów, które należy przetworzyć. Następnie każdy zegar ma trzy wiersze wejścia zawierające liczby całkowite w następującym formacie:

x y z
h m s
t

Znaczenie każdej litery jest poniżej.

x = liczba godzin na dzień (2 <= x <= 99)
y = liczba minut na godzinę (2 <= y <= 100)
z = liczba sekund na minutę (2 <= z <= 100)
h = godzina czasu rozpoczęcia (1 <= h <= x)
m = minuta czasu rozpoczęcia (0 <= m <y)
s = sekunda czasu rozpoczęcia (0 <= s <z)
t = liczba sekund, które upłynęły

Wyjściem musi być czas zakończenia każdego zegara po upływie t sekund od czasu rozpoczęcia. Dane wyjściowe muszą być sformatowane jako standardowy zegar (GG: MM: SS). W razie potrzeby liczby należy uzupełnić, aby zapewnić, że wszystkie liczby są dwucyfrowe.

Przypadki testowe

Wejście

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

Wynik

04:13:08
02:08:03

Wejście

1
14 17 11
12 16 10
1530

Wynik

07:03:00

Wejście

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

Wynik

05:26:10
14:00:00

GolfScript - 50 znaków

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

Wartości (H / M / S) są zbierane przez przeniesienie ich na przód stosu ( ])\). Godzina „niedomiaru” przy 0 jest obsługiwana za pomocą or. Wypełnienie zerowe jest obsługiwane 100+`(;, chociaż przypuszczam, że 0`\+-2>ma tę samą długość.

Python, 142 znaki

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 znaków

Edycja: Udało mi się uzyskać tablicę, która wcześniej była przechowywana na stosie, zajmuje to trochę dodatkowego przełączenia w ten sposób, więc nie ma znaczącej poprawy.

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

Wersja 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

Jestem pewien, że można to zrobić o wiele lepiej, po prostu nie mogłem wymyślić nic lepszego.

1: Zrób tablicę wszystkich danych wejściowych, wybierz pierwszy element, zgrupuj resztę w bloki 7.
a / 13: Zużyj pierwszą liczbę z danych wejściowych, aby uruchomić pętlę tyle razy.
2: Przechowuj pustą tablicę w.
3: Wybierz blok 7 i rozwiń go do 7 pojedynczych liczb.
b / 8: Uruchom pętlę 3 razy, raz na każdą sekundę, minutę i godzinę.
4: Dodaj razem dwie ostatnie liczby, dla pierwszej iteracji, która jest sekundą i czasem do przesunięcia, dla następnej będą to minuty i godzina z przelewem z poprzedniego cyklu. Zrób drugą kopię wyniku.
5: Podziel kopię przez jej limit, aby spowodować przepełnienie i przesuń wynik o jedną spację do tyłu.
6: Oblicz moduł poprzedniego podziału, aby uzyskać część wyniku.
7: Dodaj tę część do tablicy.
9: Usuń przepełnienie godziny oraz limity sekund i minut ze stosu.
10: Weź część godziny, jeśli jest zero, zamień ją na limit godzin, włóż z powrotem do tablicy.
11: Dla każdego elementu w a, umieść „0” z przodu, konwertując w ten sposób na ciąg znaków i wyrzuć wszystko oprócz ostatnich 2 znaków.
12: Zwiń tablicę w pojedynczy ciąg rozdzielany znakiem „:”, umieść nowy wiersz i przesuń tablicę zawierającą pozostałe zadania na wierzch stosu, przygotowując w ten sposób do następnej iteracji.

J (172/35) 137 99 107

Teraz przechodzi wszystkie podane przypadki testowe.

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 to wszystko; 35 to liczba znaków, które dałbym, gdybym był naprawdę sprytny i odmówił wykonania IO, jak wskazano. (Nadal go trochę zmodyfikowałem; zegary to funkcja przyjmująca nazwę pliku, która ma być używana interaktywnie w J.)

Mam nadzieję, że w J jest to o wiele łatwiejsze, niż się wydaje.

Edycja: Zorientowałem się, jak lepiej analizować dane wejściowe w J, wyeliminowałem charsub, przełączono na wywołanie i wyjście z wiersza poleceń.

Edycja 2: Zmieniono wprowadzanie funkcji centralnej na macierz 3x3, wyeliminowano wiele irytujących nawiasów, wyeliminowano nazwy

Edycja 3: Obsługiwana godzina 0.

Wyjaśnienie:

Moje J wciąż nie jest świetne, a IO jest bólem jak zawsze. Więc to jest wariactwo.

• Czasownik 1 0 0+{.#:{.&{:+{.#.1 0 0-~1&{przyjmuje macierz trzy na trzy (składające się z linii wejściowych, ostatnie dwa elementy są śmieciami)
• H / m / s jest uzyskiwane z {. (głowa), rzeczywisty czas z 1 i {(drugi element), a drugi zlicza z {. & {: (głowa ogona).
• Czasownik używa #. przekształcić czas zegara na sekundy. (Patrz dokumentacja.)
• Dodaje drugą liczbę, a następnie używa #: aby uzyskać odpowiedź na 3 elementy.
• Przypadek godziny 0 jest obsługiwany przez odjęcie 1 od godziny przed zmianą bazy i dodanie 1 z powrotem po. (dwa bity z 1 0 0)
• Reszta to dane wejściowe i wyjściowe, które są naprawdę brudne (jak zawsze).
• ".;._2(1!:1)3 otrzymuje 3-kolumnową macierz danych wejściowych z zerami w niewypełnionych pozycjach.
• ,&}.$~,&3 3&{.&{. odcina pierwszy wiersz od wejścia i kształtuje pozostałe wiersze w Nx3x3.
• W "2modyfikuje centralny czasownik wziąć 3x3 przypadki.
• 10 10&#:daje 2 cyfry dziesiętne dla każdej liczby, dając macierz Nx3x2. (Zdobycie zer dla wypełnienia było uciążliwe ).
• ,"2":"0 konwertuje cyfry na ASCII (Nx3x2x1) i ravels ostatnią kolumnę, dając Nx3x2 ponownie jako ASCII.
• LF,~"1([,':',])/"2 wstawia: między każdym elementem i dołącza je (Nx7) i dodaje znak wiersza dla dla (Nx8).
• 4(1!:2)~ drukuje każdy rząd.

Haskell, 159 znaków

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

• Edycja: (207 -> 200) czasami divModnie jest tego warte!
• Edycja: (200 -> 178) nie poddał się eleganckiemu foldrpodejściu (które działa w systemach czasowych z dowolną liczbą komponentów!)
• Edycja: (178 -> 164) wstawiona f
• Edycja: (164 -> 158) usunęło niepotrzebne nawiasy
• Edycja: (158 -> 160) naprawiono nieco wprowadzony trzy zmiany temu: godziny są teraz znowu poprawne
• Edycja: (160 -> 159) odrzucił połączenie z tail

Ruby, 128 znaków

Bezwstydnie kopiuje z 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 niezbędnych znaków

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 znaków)

Pobiera dane wejściowe z pliku przekazanego jako argument.

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

I bez golfa:

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

I dla przypomnienia, bez pieczęci (znak dolara), ma to 205 znaków.

Java, 486 371 znaków

Wersja bez golfa: http://pastebin.com/6LiTdGyi

Daje to taką samą wydajność jak w podanych przykładach.

Nie zgadzam się jednak z tym zachowaniem: zegar nie ma tylu liczb, ile godzin dziennie: ma ich połowę.

Oznacza to, że jeśli dodasz 3600 sekund do 12:50:12, powinien wypisać 01:50:12, a nie 13:50:12 (w naszym standardowym systemie 24/60/60).

Zrobiłem to w moim kodzie, ale skomentowałem to w moim rozwiązaniu, aby pasowało do przykładów. Oczywiście, jeśli weźmiesz to pod uwagę, czasy wprowadzania można uznać za dwuznaczne, chyba że dodasz znacznik AM / PM.

Ale w każdym razie łamigłówka jest niespójna: jeśli 00 godzin należy zastąpić x, wówczas godziny> (x / 2) należy zastąpić godzinami - (x / 2).

Edycja: Wersja w golfa:

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 znaków:

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 znaków

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

Plik musi zostać przekazany do skryptu jako argument

Nie golfowany:

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

Dziennik zmian:

229 -> 228: Nie trzeba ustalać pozostałego czasu podczas podziału na godziny

Bash, 139 znaków

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 znaków:

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

Twierdzę, że w sprzeczności z przepisami

14 15 20
1 14 0
-580

Wynik nie powinien być

14:00:00

ale

00:00:00

i to właśnie tworzy mój kod. Pokaż mi zegar, który wyświetla na Ziemi 24:00:00 zamiast 00:00:00 - może 24:59:59. A może spodziewasz się sekwencji:

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

zamiast

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

Python 2 , 137 bajtów

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

Wypróbuj online!

Tylko nieco krótszy niż druga odpowiedź w Pythonie , ale dotarcie inną drogą.

Niegolfowane Objaśnienie:

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 znaków bez golfa, z wyłączeniem pustych linii)

Moje wydruki 00:00:00 zamiast 12:00:00 lub podobne w przypadku „północy”. Edycja: zmieniłem to.

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'

Mógłbym wyodrębnić jeszcze kilka rzeczy, ale w / e. Całkowicie ignoruje pierwszą linię pliku wejściowego i generalnie krzyczy na ciebie za niepoprawnie sformatowane pliki.