Sau đây được lấy cảm hứng từ một câu hỏi xuất hiện trên Stack Overflow ngày hôm nay .

Cho một số micro giây, 0 <= n <= 86400000000(ví dụ 12345678900), xuất ra một chuỗi được định dạng hh:mm:ss:000:000, ví dụ 03:25:45:678:900.

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

Tôi có một giải pháp bằng Python với 209 byte, nhưng nó có thể xuống thấp hơn không?

Python 2, 82 79 byte

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

Xây dựng chuỗi, lặp qua một loạt các divmod. Bit ưa thích duy nhất là %7/2, bản đồ 1000 -> 3và 60 -> 2.

Bình thường, 31 byte

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

Dùng thử trực tuyến: Trình diễn

Giải trình:

                                 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

Ngôn ngữ "chính thống" ngắn nhất cho đến nay ...

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

Đầu ra thử nghiệm:

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

Điều này là dài đẹp .. Chơi gôn bây giờ ..

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

CẬP NHẬT: Đã lưu 1 byte nhờ @ Sp3000

Dùng thử trực tuyến tại đây

C, 97 byte

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)

Mã kiểm tra:

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

q (34)

Tôi chắc rằng nó có thể ngắn hơn

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

ví dụ

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

Julia, 110 96 95 byte

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

Điều này tạo ra một hàm không tên chấp nhận một số nguyên làm đầu vào và trả về một chuỗi. Để gọi nó, đặt tên cho nó, vd f=t->....

Ungolfed + giải thích:

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

Ví dụ:

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 byte

Khi bạn có nội dung theo ý của bạn, tại sao không sử dụng chúng?

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

Với định dạng tốt hơn:

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 ký tự

Giả sử micro giây của bạn là A1 :

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

Đầu ra:

        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 byte

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

77 byte mã, +1 cho -ncờ. Chạy với:

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

Cảm ơn Thomas Kwa và chilemagic đã cắt giảm kích thước mã của tôi gần một nửa.

Matlab - 88 89 byte

Đạt được một byte với một giải pháp mà không sử dụng hàm dựng sẵn:

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

Tạo một hàm nội tuyến có một đối số đầu vào số tvà trả về một chuỗi.

nó sử dụng kết hợp véc tơ fixvà modđể tách các yếu tố thời gian, sau đó hiển thị.

thật là một chút bực bội khi định dạng của chuỗi đầu ra mất quá nhiều, hơn cả các phép tính ...

Kiểm tra:

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

Phiên bản 89 byte:

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

Nó phân chia số, sử dụng hàm tích hợp cho phần hh: mm: ss, không thể xử lý với micro giây để chuỗi được hoàn thành với sự kết hợp fixvà modhoạt động

JavaScript (ES6), 128 118 116 111 byte

Có lẽ có một số tiềm năng chơi golf trong này.

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

Bản giới thiệu

Đó là ES6 nên Firefox chỉ, cho đến bây giờ dù sao đi nữa:

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 byte

EDIT: loại bỏ thêm một số byte

CỐ ĐỊNH: loại bỏ loại dài, nhờ một số người dùng

Không phải là câu trả lời C ngắn nhất, nhưng tôi đã có một số niềm vui với việc trả lại xe ngựa nên tôi cảm thấy như ai đó có thể thích điều này.

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

Gọi nó như:

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

    return 0;
}

CoffeeScript, 127 byte

Thực hiện cách tiếp cận trong câu trả lời của ASCIIThenANSI . Thật tệ khi API Bảng điều khiển JavaScript không có trình giữ chỗ định dạng cho số đệm.

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)

Sử dụng

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 byte

Lặp lại đầu tiên: Ý tưởng cơ bản.

Lặp lại thứ hai: Các hằng số nhỏ hơn

Lặp lại thứ ba: Định dạng chính xác cho các phần chữ số đơn.

Lưu ý chức năng này phải được cung cấp một int64 để hoạt động.

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)

Kết quả ví dụ:

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

PHP - 115 102 byte

Một giải pháp trong 155 byte (được gói ở đây trên 3 dòng để dễ đọc):

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

Dòng thứ hai tính toán (từ trong ra ngoài) các giá trị chính xác của các thành phần bắt đầu bằng micro giây.

Phiên bản ngắn hơn (115 byte, được gói trên hai dòng để dễ đọc):

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

Nó cũng sử dụng các bài tập được nhúng để tính toán chuyển đổi số lượng đầu vào của micro giây theo mili giây, giây, phút và giờ bằng cách sử dụng số dấu phẩy động. Toán tử mô đun ( %) và định dạng số thập phân ( %d) của printf()sau đó được sử dụng để buộc chúng thành số nguyên (phần phân số bị bỏ qua).

Một giải pháp khác sử dụng các hàm ngày (102 byte)

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

Phần giờ: phút: giây được xử lý bởi các hàm ngày PHP gmdate()và strtotime(), phần nghìn và micro giây được trích xuất dưới dạng chuỗi từ giá trị đầu vào.

Sử dụng:

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

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

Phương thức fthực hiện một số tính toán nđể tính ra giờ, phút, v.v. và ủy quyền cho phương thức pđịnh dạng chính xác từng giá trị.

Định dạng:

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

Sử dụng:

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

Ruby - 82 byte

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