Das Folgende ist von einer Frage inspiriert , die heute bei Stack Overflow gestellt wurde .

Bei einer gegebenen Anzahl von Mikrosekunden 0 <= n <= 86400000000(z. B. 12345678900) wird eine formatierte Zeichenfolge ausgegeben hh:mm:ss:000:000, z 03:25:45:678:900.

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

Ich habe eine Lösung in Python in 209 Bytes, aber kann es niedriger gehen?

Python 2, 82 79 Bytes

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

Erstellt den String und durchläuft eine Reihe von Divmods. Das einzig ausgefallene ist das %7/2, welches 1000 -> 3und abbildet 60 -> 2.

Pyth, 31 Bytes

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

Probieren Sie es online aus: Demonstration

Erläuterung:

                                 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

Kürzeste "Mainstream" -Sprache bisher ...

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

Testausgang:

$ 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 Bytes

Das ist ziemlich lang .. Golf jetzt ..

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

UPDATE: 1 Byte gespart dank @ Sp3000

Probieren Sie es hier online aus

C 97 Bytes

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)

Testcode:

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

q (34)

Ich bin sicher, dass es kürzer sein kann

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

z.B

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

Julia, 110 96 95 Bytes

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

Dadurch wird eine unbenannte Funktion erstellt, die eine Ganzzahl als Eingabe akzeptiert und eine Zeichenfolge zurückgibt. Um es zu nennen, geben Sie ihm einen Namen, z f=t->....

Ungolfed + Erklärung:

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

Beispiele:

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 Bytes

Wenn Sie über integrierte Funktionen verfügen, können Sie diese verwenden.

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,":"));}

Mit besserer Formatierung:

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 Zeichen

Angenommen, Ihre Mikrosekunden sind in A1 :

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

Ausgabe:

        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 Bytes

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

77 Byte Code, +1 für das -nFlag. Laufen mit:

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

Vielen Dank an Thomas Kwa und chilemagic, die meinen Code fast halbiert haben.

Matlab - 88 89 Bytes

Erhalten Sie ein Byte mit einer Lösung, ohne die eingebaute Funktion zu verwenden:

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

Erstellen Sie eine Inline-Funktion, die ein numerisches Eingabeargument akzeptiert tund eine Zeichenfolge zurückgibt.

Es verwendet eine vektorisierte Kombination von fixund mod, um die Zeitelemente zu trennen und dann anzuzeigen.

Es ist ein bisschen frustrierend, dass die Formatierung des Ausgabe-Strings so viel Zeit in Anspruch nimmt, mehr als die Berechnungen selbst ...

Prüfung:

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

89-Byte-Version:

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

Es teilt die Zahl auf und verwendet eine eingebaute Funktion für den Teil hh: mm: ss, der keine Mikrosekunden verarbeiten kann, sodass die Zeichenfolge mit einer Kombination aus fixund modOperationen vervollständigt wird

JavaScript (ES6), 128 118 116 111 Byte

Darin liegt wahrscheinlich ein gewisses Golfpotential.

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

Demo

Es ist ES6, also nur Firefox, für den Moment sowieso:

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 Bytes

EDIT: einige Bytes mehr abgeschoben

UPDATE: langer Typ wurde dank einiger Benutzer entfernt

Nicht die kürzeste C-Antwort, aber ich hatte ein bisschen Spaß mit Wagenrückläufen, also hatte ich das Gefühl, dass jemand dies mögen könnte.

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("");

Nennen Sie es wie folgt:

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

    return 0;
}

CoffeeScript, 127 Bytes

Nahm den Ansatz in der Antwort von ASCIIThenANSI . Es ist schade, dass die JavaScript- Konsolen-API keine Formatplatzhalter zum Auffüllen von Zahlen enthält.

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)

Verwendung

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 Bytes

Erste Iteration: Grundidee.

Zweite Iteration: Kleinere Konstanten

Dritte Iteration: Korrekte Formatierung für einstellige Teile.

Beachten Sie, dass für diese Funktion ein int64 angegeben werden muss, um zu funktionieren.

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)

Beispielausgaben:

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

PHP - 115 102 Bytes

Eine Lösung in 155 Bytes (hier aus Gründen der Lesbarkeit in 3 Zeilen eingeschlossen):

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

Die zweite Zeile berechnet (von innen nach außen) die genauen Werte der Komponenten, beginnend mit den Mikrosekunden.

Die kürzere Version (115 Bytes, aus Gründen der Lesbarkeit in zwei Zeilen eingeschlossen):

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

Außerdem werden eingebettete Zuweisungen verwendet, um die eingegebene Anzahl von Mikrosekunden in Millisekunden, Sekunden, Minuten und Stunden mithilfe von Gleitkommazahlen zu berechnen. Der Moduloperator ( %) und das Dezimalzahlenformat ( %d) von printf()werden dann verwendet, um sie zu Ganzzahlen zu zwingen (der Bruchteil wird ignoriert).

Eine andere Lösung, die die Datumsfunktionen verwendet (102 Bytes)

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

Die Stunden: Minuten: Sekunden Teil wird von den PHP Datumsfunktionen behandelt gmdate()und strtotime()die Milli- und Mikrosekunden werden als Zeichenfolge aus dem Eingangswert extrahieren.

Verwendung:

$ 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 Bytes

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

Methode fführt einige Berechnungen durch n, um die Stunden, Minuten usw. zu berechnen p, und delegiert an Methode, um jeden Wert korrekt zu formatieren.

Formatiert:

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

Verwendung:

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

Ruby - 82 Bytes

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