Le code le plus court pour générer les heures correctes sur les horloges gagne.

Vous êtes un voyageur temporel aguerri et vous êtes connu pour vous arrêter à de nombreuses planètes au cours de vos journaux. Chaque planète tourne à un rythme différent et pour cette raison, la durée d'une journée est différente de notre journée habituelle de 24 heures. En conséquence, les planètes utilisent des horloges avec différents nombres d'heures. Les heures sur une horloge avec x heures sont disposées de manière similaire à la nôtre (1, 2, 3, ..., x ) avec le nombre tournant dans le sens horaire et x étant en haut.

De plus, chaque planète a un nombre différent de minutes en une heure et un nombre différent de secondes en une minute. Vous recevrez une heure de début et un nombre de secondes écoulées à partir desquelles vous devrez déterminer l'heure de fin.

L'entrée peut être prise directement à partir d'un fichier passé en argument ou en entrée standard. La première ligne d'entrée sera le nombre d'horloges à traiter. Après cela, chaque horloge a trois lignes d'entrée qui contiennent des entiers au format suivant:

x y z
h m s
t

La signification de chaque lettre est ci-dessous.

x = Le nombre d'heures dans une journée (2 <= x <= 99)
y = Le nombre de minutes dans une heure (2 <= y <= 100)
z = Le nombre de secondes dans une minute (2 <= z <= 100)
h = L'heure de l'heure de démarrage (1 <= h <= x)
m = La minute de l'heure de démarrage (0 <= m <y)
s = La seconde de l'heure de démarrage (0 <= s <z)
t = Le nombre de secondes qui se sont écoulées

La sortie doit être l'heure de fin de chaque horloge après que t secondes se sont écoulées depuis l'heure de début. Votre sortie doit être formatée en temps d'horloge standard (HH: MM: SS). Les chiffres doivent être remplis, si nécessaire, pour garantir que tous les chiffres sont à deux chiffres.

Cas de test

Contribution

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

Production

04:13:08
02:08:03

Contribution

1
14 17 11
12 16 10
1530

Production

07:03:00

Contribution

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

Production

05:26:10
14:00:00

GolfScript - 50 caractères

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

Les valeurs (H / M / S) sont collectées en les déplaçant vers l'avant de la pile ( ])\). L'heure de sous-dépassement à 0 est gérée avec or. Le remplissage zéro est géré avec 100+`(;, bien que je suppose que 0`\+-2>c'est la même longueur.

Python, 142 caractères

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 caractères

Edit: J'ai réussi à obtenir le tableau anciennement stocké dans un pour résider sur la pile, il faut un peu de commutation supplémentaire de cette façon, donc aucune amélioration majeure.

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

Version 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

Je suis sûr que cela peut être fait beaucoup mieux, je ne pouvais pas penser à mieux.

1: Faites un tableau de toutes les entrées, sélectionnez le premier élément, regroupez le reste en blocs de 7.
a / 13: Consommez le premier nombre de l'entrée pour exécuter la boucle autant de fois.
2: Stockez un tableau vide dans a.
3: Choisissez un bloc de 7 et développez-le à 7 numéros individuels.
b / 8: Exécutez une boucle 3 fois, une fois pour chacune des secondes, minutes et heures.
4: Additionnez les deux derniers nombres ensemble, pour la première itération qui est les secondes et le temps à décaler, pour les suivants ce sont les minutes et les heures avec le débordement du cycle précédent. Faites une deuxième copie du résultat.
5: Divisez la copie par sa limite pour produire le débordement et reculer le résultat d'un espace.
6: Calculez le modulo de la division précédente pour produire une partie du résultat.
7: Ajoutez cette partie au tableau a.
9: Retirez le dépassement d'heure et les limites des deuxième et minute de la pile.
10: Prenez la partie horaire d'un, si elle est nulle, remplacez-la par la limite horaire, remettez-la dans le tableau.
11: Pour chaque élément de a, placez «0» devant, convertissant ainsi en chaîne, et jetez tout sauf les 2 derniers caractères.
12: Réduisez le tableau en une seule chaîne délimitée par «:», placez une nouvelle ligne et déplacez le tableau contenant les travaux restants à l'avant de la pile, préparant ainsi la prochaine itération.

J (172/35) 137 99 107

Passe maintenant tous les cas de test donnés.

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 est le tout; 35 est le nombre de caractères que je donnerais si j'étais vraiment arrogant et refusais de faire l'IO comme indiqué. (Je l'ai quand même légèrement modifié; horloges est une fonction qui prend un nom de fichier destiné à être utilisé de manière interactive dans J.)

J'espère bien que c'est beaucoup plus facile en J que je ne le pense.

Edit: Compris comment améliorer l'analyse syntaxique des entrées dans J, éliminé charsub, basculé vers l'invocation et la sortie de la ligne de commande.

Édition 2: modification de l'entrée de la fonction centrale dans la matrice 3x3, suppression de nombreuses parenthèses embêtantes, suppression des noms

Modifier 3: 0-heures traitées.

Explication:

Mon J n'est toujours pas génial, et IO est une douleur comme toujours. Donc, des morceaux de cela sont loufoques.

• Le verbe 1 0 0+{.#:{.&{:+{.#.1 0 0-~1&{prend une matrice de trois par trois (composé des lignes d'entrée, les deux derniers éléments sont des ordures)
• Le h / m / s est obtenu avec {. (tête), le temps réel avec 1 & {(deuxième élément), et le deuxième compte avec {. & {: (tête de queue).
• Le verbe utilise #. pour transformer le temps d'horloge en secondes. (Voir documentation.)
• Il ajoute le deuxième décompte, puis utilise #: pour obtenir la réponse à 3 éléments.
• Le cas de 0 heure est géré en soustrayant 1 de l'heure avant le changement de base et en ajoutant 1 après. (les deux bits avec 1 0 0)
• Le reste est entrée et sortie, ce qui est vraiment sale (comme toujours).
• ".;._2(1!:1)3 obtient une matrice de 3 colonnes de l'entrée avec 0 dans les positions non remplies.
• ,&}.$~,&3 3&{.&{. coupe la première ligne de l'entrée et façonne les lignes restantes en Nx3x3.
• Le "2modifie le verbe central pour prendre les cas 3x3.
• 10 10&#:donne 2 chiffres décimaux pour chaque nombre donnant une matrice Nx3x2. (Obtenir des 0 pour le rembourrage était une douleur .)
• ,"2":"0 convertit les chiffres en ASCII (Nx3x2x1) et défile la dernière colonne, donnant à nouveau Nx3x2 en ASCII.
• LF,~"1([,':',])/"2 insère: entre chaque élément et les ajoute (Nx7) et ajoute un saut de ligne par pour (Nx8).
• 4(1!:2)~ imprime chaque ligne.

Haskell, 159 caractères

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) parfois divModne vaut pas la peine!
• Edit: (200 -> 178) a succombé à ne pas utiliser l' foldrapproche élégante (qui fonctionne pour les systèmes de temps avec un certain nombre de composants!)
• Modifier: (178 -> 164) en ligne f
• Modifier: (164 -> 158) a supprimé les parenthèses inutiles
• Edit: (158 -> 160) corrigé un peu introduit il y a trois modifications: les heures sont à nouveau correctes
• Modifier: (160 -> 159) a abandonné un appel à tail

Rubis, 128 caractères

Copies sans vergogne du 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 caractères nécessaires

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 caractères)

Prend l'entrée d'un fichier passé en 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);}

Et non golfé:

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

Et juste pour noter, sans sceaux (le signe dollar), cela donne 205 caractères.

Java, 486 371 caractères

Version non golfée: http://pastebin.com/6LiTdGyi

Cela donne la même sortie que dans les exemples fournis.

Mais je ne suis pas d'accord sur ce comportement: une horloge n'a pas autant de chiffres qu'il y a d'heures dans une journée: elle en a la moitié.

Cela signifie que si vous ajoutez 3600 secondes à 12:50:12, il devrait imprimer 01:50:12, pas 13:50:12 (dans notre système standard 24/60/60).

J'ai géré cela dans mon code, mais je l'ai commenté dans ma solution pour qu'il corresponde aux exemples. Bien sûr, si vous considérez cela, les temps d'entrée peuvent être considérés comme ambigus, sauf si vous ajoutez un marqueur AM / PM.

Mais dans tous les cas, le puzzle présente une incohérence: si 00 heures doivent être remplacées par x, alors heures> (x / 2) doivent être remplacées par heures - (x / 2).

Edit: Version golfée:

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 caractères:

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 caractères

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

Le fichier doit être passé dans le script comme argument

Non golfé:

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

Journal des modifications:

229 -> 228: Pas besoin de régler le temps restant lors de la division des heures

Bash, 139 caractères

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 caractères:

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

En contradiction avec les règles, je prétends que

14 15 20
1 14 0
-580

La sortie ne doit pas être

14:00:00

mais

00:00:00

et c'est ce que mon code produit. Veuillez me montrer une horloge qui affiche 24:00:00 sur terre au lieu de 00:00:00 - peut-être 24:59:59. Ou attendez-vous la séquence:

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

au lieu de

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

Python 2 , 137 octets

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

Essayez-le en ligne!

Un peu plus court que le autre réponse Python , mais prend un chemin différent pour y arriver.

Explication non golfée:

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 caractères non golfés, lignes blanches exclues)

Le mien imprime 00:00:00 au lieu de 12:00:00 ou similaire pour les heures de type "minuit". Edit: changé cela.

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'

Aurait pu résumer quelques choses de plus, mais w / e. Il ignore complètement la première ligne du fichier d'entrée et vous crie généralement pour les fichiers mal formatés.