Ce qui suit est inspiré d' une question posée sur Stack Overflow aujourd'hui .

Étant donné un certain nombre de microsecondes, 0 <= n <= 86400000000(par exemple 12345678900), sortir une chaîne formatée hh:mm:ss:000:000, par exemple 03:25:45:678:900.

          0 -> '00:00:00:000:000'
12345678900 -> '03:25:45:678:900'
86400000000 -> '24:00:00:000:000'

J'ai une solution en Python en 209 octets, mais peut-elle aller plus bas?

Python 2, 82 79 octets

n=input()
o=""
for k in[1000]*2+[60]*3:o=":%0*d"%(k%7/2,n%k)+o;n/=k
print o[1:]

Construit la chaîne, itérant à travers une série de divmods. Le seul bit fantaisie est le %7/2, qui mappe 1000 -> 3et 60 -> 2.

Pyth, 31 octets

j\:_m>l`td+"00"%~/QddCM"ϨϨ<<<

Essayez-le en ligne: Démonstration

Explication:

                                 implicit: Q = input number
                       "ϨϨ<<<   string "ϨϨ<<<" (5 chars but 7 bytes)
                     CM          convert each to number => [1000, 1000, 60, 60, 60]
    m                            map each number d to:
                 /Qd                divide Q by d
                ~                   and update Q with the new value
               %~ Q d               but use the old value to calculate Q mod d
          +"00"                     add the result to the string "00"
     >                              but only take the last 
      l`td                          len(str(d-1)) chars
   _                             revert order
j\:                              join the strings with ":"s

Bash + coreutils, 61

La langue "mainstream" la plus courte à ce jour ...

a=%02d:
printf $a$a$a%03d:%03d `dc -e$1\ A00~rA00~r60~r60~rf`

Sortie de test:

$ for t in 0 12345678900 86400000000; do ./usec.sh $t; echo; done
00:00:00:000:000
03:25:45:678:900
24:00:00:000:000
$ 

CJam, 37 35 34 octets

C'est assez long .. Jouer au golf maintenant ..

ri[1e3_60__]{:ImdsIBb,0e[':@}%W%2>

MISE À JOUR: 1 octet enregistré grâce à @ Sp3000

Essayez-le en ligne ici

C, 97 octets

q=1000,s=60;
#define f(n)printf("%02d:%02d:%02d:%03d:%03d",n/s/s/q/q,n/s/q/q%s,n/q/q%s,n/q%q,n%q)

Code de test:

int main(int intc, char **argv)
{
    long long n = atoll(argv[1]);
    f(n);
}

q (34)

Je suis sûr que ça peut être plus court

":"sv 0 8 11__[;8]15$2_($)16h$1e3*

par exemple

q)f:":"sv 0 8 11__[;8]15$2_($)16h$1e3*
q)f 12345678900
"03:25:45:678:900"

Julia, 110 96 95 octets

t->(o="";for i=int([36e8,6e7,1e6,1e3,1]) x,t=t÷i,t%i;o*=lpad(x,i>1e3?2:3,0)*":"end;o[1:end-1])

Cela crée une fonction sans nom qui accepte un entier en entrée et renvoie une chaîne. Pour l'appeler, donnez-lui un nom, par exemple f=t->....

Non golfé + explication:

function f(t)
    # Initialize an output string
    o = ""

    # Loop over an array consisting of the number of microseconds in
    # an hour, minute, second, millisecond, and microsecond
    for i = int([36e8, 6e7, 1e6, 1e3, 1])

        # Get the quotient and remainder for microseconds into t,
        # setting t to be the remainder
        x, t = t ÷ i, t % i

        # Left-pad x with zeroes and append it to the output
        o *= lpad(x, i > 1e3 ? 2 : 3, 0) * ":"
    end

    # o has a trailing :, so return everything but the last character
    o[1:end-1]
end

Exemples:

julia> f(12345678900)
"03:25:45:678:900"

julia> f(0)
"00:00:00:000:000"

julia> f(86400000000)
"24:00:00:000:000"

C #, 179 175 octets

Lorsque vous avez des buildins à votre disposition, pourquoi ne pas les utiliser?

static void Main(string[]a){var t=TimeSpan.FromTicks(long.Parse(Console.ReadLine())*10);Console.Write(t.ToString((t.Days<1?"hh":@"\2\4")+@"\:mm\:ss\:ffffff").Insert(12,":"));}

Avec un meilleur formatage:

static void Main(string[]a){
    var t = TimeSpan.FromTicks(long.Parse(Console.ReadLine())*10);
    Console.Write(t.ToString((t.Days<1?"hh":@"\2\4")+@"\:mm\:ss\:ffffff").Insert(12,":"));
    Console.Read();
}

Excel, 65 63 caractères

En supposant que vos microsecondes soient en A1 :

=TEXT(A1/50/1200^3,"[HH]:mm:ss:")&RIGHT(TEXT(A1,"000\:000"),7)

Sortie:

        A              B
1            0  00:00:00:000:000
2  12345678900  03:25:46:678:900
3  86400000000  24:00:00:000:000

Perl, 141 78 octets

printf"%02d"x3.%03d:%03d",$_/36e8,$_/6e7%60,$_/1e6%60,$_/1e3%1e3,$_‌​%1e3

77 octets de code, +1 pour le -ndrapeau. Courir avec:

echo 12345678900 | perl -ne'printf"%02d"x3.%03d:%03d",$_/36e8,$_/6e7%60,$_/1e6%60,$_/1e3%1e3,$_‌​%1e3'

Merci à Thomas Kwa et à chilemagic d'avoir réduit de moitié la taille de mon code.

Matlab - 88 89 octets

Obtention d'un octet avec une solution sans utiliser la fonction intégrée:

n=[36e8,6e7,1e6,1e3];f=@(t)sprintf('%02d:%02d:%02d:%03d:%03d',fix([t mod(t,n)]./[n 1]))

Créez une fonction en ligne qui prend un argument d'entrée numérique tet renvoie une chaîne.

il utilise une combinaison vectorisée de fixet modpour séparer les éléments de temps, puis affiche.

c'est un peu frustrant que le formatage de la chaîne de sortie prenne autant, plus que les calculs eux-mêmes ...

Tester:

for t=[0 12345678900 86400000000]
    f(t)
end

ans =
00:00:00:000:000
ans =
03:25:45:678:900
ans =
24:00:00:000:000

Version 89 octets:

f=@(t)sprintf('%s:%03d:%03d',datestr(fix(t/1e6)/86400,13),fix(mod(t,1e6)/1e3),mod(t,1e3))

Il divise le nombre, utilise une fonction intégrée pour la partie hh: mm: ss, qui ne peut pas traiter les microsecondes, donc la chaîne est complétée par la combinaison de fixet les modopérations

JavaScript (ES6), 128 118 116 111 octets

Il y a probablement un certain potentiel de golf là-dedans.

f=t=>(t<864e8?new Date(t/1e3).toJSON().slice(11,-1):`24:00:00:000`).replace(`.`,`:`)+':'+('00'+t%1e3).slice(-3)

Démo

C'est ES6 donc Firefox uniquement, pour l'instant de toute façon:

f=t=>(t<864e8?new Date(t/1e3).toJSON().slice(11,-1):`24:00:00:000`).replace(`.`,`:`)+':'+('00'+t%1e3).slice(-3)

// DEMO
document.body.innerHTML += '<br>' + f(0);
document.body.innerHTML += '<br>' + f(12345678020);
document.body.innerHTML += '<br>' + f(86400000000);

C, 113 103 105 105 octets

EDIT: bousculé quelques octets supplémentaires

CORRECTIF: suppression du type long, grâce à un utilisateur

Pas la réponse la plus courte en C, mais je me suis amusé avec les retours chariot, donc je me sentais comme si quelqu'un pouvait aimer ça.

i,k,p=16;
#define f(n)for(;i<5;p-=i++<2?4:3)k=i<2?1000:60,printf("%0*d%c\r",p,n%k,i?58:13),n/=k;puts("");

Appelez ça comme:

int main() {
    long long n = 12345678900;
    f(n);

    return 0;
}

CoffeeScript, 127 octets

A adopté l'approche dans la réponse d'ASCIIThenANSI . Il est dommage que l' API de la console JavaScript n'ait pas d'espace réservé au format pour les nombres de remplissage.

p=(a,b)->('00'+~~a).slice -b||-2
f=(t)->console.log '%s:%s:%s:%s:%s',p(t/36e8),p(t/6e7%60),p(t/1e6%60),p(t/1e3%1e3,3),p t%1e3,3

Powershell, 153

$t=[timespan]::FromTicks(($a=$args[0]));"{0:D2}:{1:D2}:{2:D2}:{3:D3}:{4:000}"-f
[int]($t.TotalHours),$t.Minutes,$t.Seconds,$t.Milliseconds,(($a%1e4)/10)

Usage

powershell -nologo .\modprintsec.ps1 123456789000    
03:25:45:678:900   
powershell -nologo .\modprintsec.ps1 864000000000   
24:00:00:000:000   
powershell -nologo .\modprintsec.ps1 0   
00:00:00:000:000 

F #, 111 92 102 octets

Première itération: idée de base.

Deuxième itération: constantes plus petites

Troisième itération: formatage correct pour les portions à un chiffre.

Notez que cette fonction doit recevoir un int64 pour fonctionner.

let s,t=60L,1000L
let f n=sprintf"%02d:%02d:%02d:%03d:%03d"(n/s/s/t/t)(n/s/t/t%s)(n/t/t%s)(n/t%t)(n%t)

Exemples de sorties:

f 0L           -> "00:00:00:000:000"
f 12345678900L -> "03:25:45:678:900"
f 86400000000L -> "24:00:00:000:000"

PHP - 115 102 octets

Une solution en 155 octets (enveloppée ici sur 3 lignes pour plus de lisibilité):

$a=$argv[1];
$h=($a-($m=($a=($a-($s=($a=($a-($t=($a=($a-($u=$a%1000))/1000)%1000))/1000)%60))/60)%60))/60;
printf("%02d:%02d:%02d:%03d:%03d",$h,$m,$s,$t,$u);

La deuxième ligne calcule (de l'intérieur vers l'extérieur) les valeurs exactes des composants en commençant par les microsecondes.

La version plus courte (115 octets, sur deux lignes pour plus de lisibilité):

$u=$argv[1];$h=($m=($s=($t=$u/1000)/1000)/60)/60;
printf("%02d:%02d:%02d:%03d:%03d",$h,$m%60,$s%60,$t%1000,$u%1000);

Il utilise également des affectations intégrées pour calculer la conversion du nombre d'entrée de microsecondes en millisecondes, secondes, minutes et heures à l'aide de nombres à virgule flottante. L'opérateur de module ( %) et le format de nombre décimal ( %d) deprintf() sont ensuite utilisés pour les forcer à des nombres entiers (la partie fractionnaire est ignorée).

Une autre solution qui utilise les fonctions de date (102 octets)

$u=$argv[1];
echo gmdate("H:i:s",strtotime("@".substr($u,0,-6))),":",substr($u,-6,3),":",substr($u,-3);

La partie heures: minutes: secondes est gérée par les fonctions de date PHP gmdate()et strtotime()les milli- et micro-secondes sont extraites sous forme de chaînes de la valeur d'entrée.

Usage:

$ php -r '$u=$argv[1];echo gmdate("H:i:s",strtotime("@".substr($u,0,-6))),":",substr($u,-6,3),":",substr($u,-3);' 7198898787; echo
01:59:58:898:787

Java, 215 octets

String f(long n){return p(n/3600000000l,2)+":"+p(n/60000000%60,2)+":"+p(n/1000000%60,2)+":"+p(n/1000%1000,3)+":"+p(n%1000,3);}String p(long n,int i){String s=String.valueOf(n);while(s.length()<i){s="0"+s;}return s;}

La méthode feffectue des calculs npour calculer les heures, les minutes, etc. et délègue à la méthode ppour formater correctement chaque valeur.

Formaté:

String f(long n) {
    return p(n / 3600000000l, 2) + ":" + p(n / 60000000 % 60, 2) + ":" 
            + p(n / 1000000 % 60, 2) + ":" + p(n / 1000 % 1000, 3) + ":" + p(n % 1000, 3);
}

String p(long n, int i) {
    String s = String.valueOf(n);
    while (s.length() < i) {
        s = "0" + s;
    }
    return s;
}

Usage:

public void demo() {
    long n = 12345678900l;
    System.out.println(f(n));
}

Rubis - 82 octets

puts (t=Time.at(0,gets.to_i)).strftime("%2H:%2M:%2S:%3L:#{(t.usec%1000).to_s.rjust(3,?0)}")