Aşağıdaki, bugün Stack Overflow'ta ortaya çıkan bir sorudan ilham alıyor .

Çok sayıda mikrosaniye verildiğinde 0 <= n <= 86400000000(örneğin 12345678900), biçimlendirilmiş bir dize hh:mm:ss:000:000, örneğin 03:25:45:678:900;

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

Python'da 209 baytlık bir çözüme sahibim, ancak daha düşük olabilir mi?

Python 2, 82 79 bayt

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

Bir dizi divmod boyunca yinelenerek dizeyi oluşturur. Tek fantezi bit %7/2, hangi haritalar 1000 -> 3ve 60 -> 2.

Pyth, 31 bayt

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

Çevrimiçi deneyin: Gösteri

Açıklama:

                                 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

Şimdiye kadarki en kısa "ana akım" dil ...

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

Test çıkışı:

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

Bu bayağı uzun .. Golf oynamak şimdi ..

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

GÜNCELLEME: @ Sp3000 sayesinde 1 bayt kurtarıldı

Burada çevrimiçi deneyin

C, 97 bayt

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)

Test Kodu:

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

q (34)

Eminim daha kısa olabilir

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

Örneğin

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

Julia 110 96 95 bayt

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

Bu, bir tamsayıyı giriş olarak kabul eden ve bir dize döndüren adsız bir işlev oluşturur. Aramak için bir isim verin, örneğin f=t->....

Ungolfed + açıklama:

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

Örnekler:

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 Bayt

Emrinde yerleşikler varken, neden kullanmıyorsun?

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

Daha iyi biçimlendirme ile:

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 karakter

Mikrosaniyelerinizin A1'de olduğunu varsayalım :

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

Çıktı:

        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 bayt

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

77 bayt kod, -nbayrak için +1 . Çalıştır:

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

Kod büyüklüğümü neredeyse yarıya indirdiğim için Thomas Kwa ve chilemagic'e teşekkürler.

Matlab - 88 89 bayt

Yerleşik işlevini kullanmadan bir çözüm ile bir bayt kazanıldı:

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

Sayısal giriş bağımsız değişkenini alan bir satır içi işlevi oluşturun tve bir dize döndürün.

Bu bir vektörlü kombinasyonunu kullanır fixvemodzaman öğelerini ayırmak ayırmak için , ardından görüntüler.

çıkış dizesinin biçimlendirmesinin hesaplamaların kendisinden çok daha fazla zaman alması biraz sinir bozucu ...

Ölçek:

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 bayt sürümü:

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

Sayıyı böler, hh: mm: ss kısmı için yerleşik bir işlev kullanır, mikrosaniye ile baş edemeyen bir dizi kullanır, böylece dizge birleşimi fixve modişlemleri ile tamamlanır.

JavaScript (ES6), 128 118 116 111 bayt

Bunun içinde muhtemelen bir golf potansiyeli var.

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

gösteri

ES6'dır, bu yüzden yalnızca Firefox, şimdilik:

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 bayt

EDIT: biraz daha fazla bayt attı

Düzeltme: bazı kullanıcılar sayesinde uzun tip kaldırıldı

En kısa C cevabı değil, ancak araba dönüşleri ile biraz eğlendim, bu yüzden birinin böyle olabileceğini hissettim.

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

Buna şöyle diyoruz:

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

    return 0;
}

CoffeeScript, 127 bayt

ASCIIThenANSI'nin cevabında yaklaşımı benimsemiştir . JavaScript Konsolu API’sının dolgu sayıları için biçimlendirilmiş yer tutucuları olmaması çok kötü .

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)

kullanım

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 bayt

İlk yineleme: Temel fikir.

İkinci yineleme: Daha küçük sabitler

Üçüncü yineleme: Tek basamaklı bölümler için doğru biçimlendirme.

Bu işleve çalışma için bir int64 verilmesi gerektiğini unutmayın.

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)

Örnek çıktılar:

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

PHP - 115 102 bayt

155 baytlık bir çözüm (okunabilirlik için buraya 3 satıra sarılı):

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

İkinci satır (içeriden dışarıya) mikrosaniye ile başlayan bileşenlerin kesin değerlerini hesaplar.

Kısa versiyon (okunabilirlik için iki satıra sarılı 115 bayt):

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

Ayrıca, kayan nokta sayılarını kullanarak mikrosaniyelerin giriş sayısını milisaniye, saniye, dakika ve saat cinsinden dönüştürmeyi hesaplamak için gömülü atamaları kullanır. Modül operatörü ( %) ve ondalık sayı formatı ( %d) printf()daha sonra onları tam sayılara zorlamak için kullanılır (kesirli kısım yoksayılır).

Tarih işlevlerini kullanan başka bir çözüm (102 bayt)

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

Hours: minutes: seconds bölümü PHP tarih işlevleriyle işlenir gmdate()ve strtotime()milli ve mikro saniye giriş değerinden dizge olarak çıkarılır.

Kullanımı:

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

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

Metot f, bazı hesaplamaları nsaat, dakika vb. Çalışmalarını yapar ve pher bir değeri doğru formatlama metodunu temsil eder .

biçimlendirilmiş:

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

Kullanımı:

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

Yakut - 82 Bayt

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