다음은 오늘 Stack Overflow에서 제기 된 질문에서 영감을 얻은 것 입니다 .

여러 마이크로 초 0 <= n <= 86400000000(예 :)가 주어진 경우 12345678900형식화 된 문자열을 출력합니다 (예 hh:mm:ss:000:000:) 03:25:45:678:900.

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

파이썬에서 209 바이트의 솔루션이 있지만 더 낮아질 수 있습니까?

파이썬 2, 82 79 바이트

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

일련의 divmod를 반복하여 문자열을 작성합니다. 유일한 멋진 비트는 것입니다 %7/2매핑하는 1000 -> 3과 60 -> 2.

Pyth, 31 바이트

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

온라인으로 사용해보십시오 : 데모

설명:

                                 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

배쉬 + 코어 유틸리티, 61

지금까지 가장 짧은 "주류"언어 ...

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

테스트 출력 :

$ 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 바이트

이거 너무 오래 .. 지금 골프 ..

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

업데이트 : @ Sp3000 덕분에 1 바이트 절약

여기에서 온라인으로 사용해보십시오

C, 97 바이트

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)

테스트 코드 :

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

q (34)

더 짧을 수 있다고 확신합니다

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

예 :

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

줄리아, 110 96 95 바이트

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

이것은 정수를 입력으로 받아들이고 문자열을 반환하는 명명되지 않은 함수를 만듭니다. 호출하려면 이름을 지정하십시오 (예 :) f=t->....

언 골프 + 설명 :

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

예 :

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 #, 179175 바이트

당신이 처분에 내장을 가지고 있다면, 왜 그들을 사용하지 않습니까?

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

더 나은 형식으로 :

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

엑셀, 65 63 자

마이크로 초가 A1에 있다고 가정합니다 .

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

산출:

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

펄, 141 78 바이트

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

77 바이트의 코드, -n플래그의 경우 +1 로 실행 :

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

내 코드 크기를 거의 절반으로 줄인 Thomas Kwa와 chilemagic에게 감사합니다.

MATLAB-88 89 바이트

내장 함수를 사용하지 않고 솔루션으로 1 바이트를 얻었습니다.

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

숫자 입력 인수를 취하는 인라인 함수를 작성하십시오. t 하고 문자열을 반환 .

그것의 조합을 사용 벡터화 fix와 mod시간 요소를 분리하기 위해, 다음 디스플레이.

출력 문자열의 형식이 계산 자체보다 훨씬 많이 걸리는 것은 약간 실망 스럽습니다 ...

테스트:

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 바이트 버전 :

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

숫자를 나누고 hh : mm : ss 부분에 내장 함수를 사용합니다. 마이크로 초를 처리 할 수 ​​없으므로 문자열이 조합 fix및 mod연산으로 완료 됩니다

자바 스크립트 (ES6) 128 118 116 111 바이트

이것에는 아마도 골프 잠재력이있을 것입니다.

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

데모

ES6이므로 Firefox 만 가능합니다.

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 바이트

편집 : 더 많은 바이트를 밀어 넣었습니다.

FIX : 일부 사용자 덕분에 긴 타입 제거

가장 짧은 C 답변은 아니지만 캐리지 리턴에 재미가있어서 누군가가 이것을 좋아할 것 같은 느낌이 들었습니다.

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

다음과 같이 호출하십시오.

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

    return 0;
}

CoffeeScript, 127 바이트

ASCIIThenANSI의 답변 에서 접근 방식을 취했습니다 . JavaScript 콘솔 API 에 패딩 숫자에 대한 형식 자리 표시자가없는 것이 너무 나쁩니다 .

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

파워 쉘, 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)

용법

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 92102 바이트

첫 번째 반복 : 기본 아이디어.

두 번째 반복 : 작은 상수

세 번째 반복 : 한 자릿수 부분의 올바른 형식입니다.

작동하려면이 함수에 int64가 제공되어야합니다.

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)

출력 예 :

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

PHP- 115102 바이트

155 바이트의 솔루션 (가독성을 위해 3 줄로 줄 바꿈) :

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

두 번째 줄은 내부에서 외부로 마이크로 초로 시작하는 구성 요소의 정확한 값을 계산합니다.

더 짧은 버전 (115 바이트, 가독성을 위해 두 줄로 줄 바꿈) :

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

또한 임베디드 대입을 사용하여 부동 소수점 숫자를 사용하여 밀리 초, 초, 분 및 시간 단위의 입력 마이크로 초 변환을 계산합니다. 그런 다음 모듈러스 연산자 ( %)와 10 진수 형식 ( %d) printf()을 사용하여 정수로 강제합니다 (소수 부분은 무시 됨).

날짜 함수 (102 바이트)를 사용하는 다른 솔루션

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

시간 : 분 : 초 부분은 PHP 일 함수에 의해 처리 gmdate()및 strtotime()상기 마이크로 밀리 초 입력 값의 문자열로 추출된다.

용법:

$ 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

자바, 215 바이트

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

방법 f은 n시간, 분 등을 해결하기 위해 일부 계산 을 수행하고 메소드에 위임합니다.p 각 값을 올바르게 형식화 에 합니다.

형식화 :

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

용법:

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

루비-82 바이트

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