将微秒的格式设置为小时：分钟：秒等

28

以下内容受到今天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个字节的Python解决方案，但是它可以降低一点吗？

code-golf  date 
— 山姆
source
1
我现在意识到，这实际上不是写时间的标准格式，hh:mm:ss.000000可能会更好（更容易）。不过，现在不能去更改它。
— 山姆
1
出于好奇，SO职位是什么？
— Digital Trauma 2015年
@DigitalTrauma stackoverflow.com/questions/31251377由一个相对较新的用户使用。已经选择了正确的答案，我只是在IDLE中闲逛，想出了一种怪异的字典理解，并不是对这个问题的特别好的答案。有人看到了它，并在评论中指出了该站点。我来到这里，写了一个问题（与SO帖子稍有不同），还写了我的答案的改进版本（我还没有发布，现在对下面所有更紧凑和富想象力的答案都是多余的） 。
— 2015年
输入的小时数是否有限制？
— FUZxxl 2015年
是的，我任意地将其设置为<= 86400000000微秒，所以<= 24小时。
— 2015年

Answers:

15

Python 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。

— Sp3000
source
6

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
— 雅库比
source
5

Bash + coreutils，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
$
— 数字创伤
source
4

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);
}
— 一些用户
source
1
C语言的答案应该是一个完整的程序；不是摘要。
— NobodyNada-恢复莫妮卡2015年
问题中未提及。有某种全球性要求吗？
— 一些用户
— NobodyNada-恢复莫妮卡
否。如果您阅读了答案，仅以C为例。该规则将适用于每种语言。另外，答案也有争议-请参阅收视率最高的评论。最重要的是，问题需要明确说明是否需要完整的程序。
— 一些用户
3
这个站点上的许多答案都使用函数而不是完整的程序-例如，我认为我从未见过Java答案是完整的程序...
— Jerry Jeremiah
4

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"
— 斯克维
source
4
任何在线编译器？换句话说-我如何作为一个懒惰的人运行它？
— Optimizer
可从kx.com
— skeevey
好地方。不幸的是，此修复程序增加了一些字符
— skeevey
1
您可以在此处削减更多字节":"sv 0 8 11__[;8]15$2_($)"n"$1e3*
— WooiKent Lee
3

朱莉娅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"
— 亚历克斯·A
source
好东西。您之所以会投票是因为您启发了我的Matlab答案：-)
— Hoki 2015年
3

C＃，179175字节

当您拥有内置插件时，为什么不使用'em？

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();
}
— 卡德
source
3

Excel，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
— 手工电子食品
source
2

Perl，141岁 78字节

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

77个字节的代码，对于+1 -n标志。运行：

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

感谢Thomas Kwa和chilemagic将我的代码大小减少了近一半。

— ASCII然后是ANSI
source
我认为3600000000可以36e8。
— lirtosiast 2015年
而是chomp($n=<STDIN>);可以将其与带有-n标志（计数为1个字符）的单线运行。您也不需要int(..)每个$_。也可以应用托马斯的技巧echo 12345678900 | perl -ne'printf"%02d:%02d:%02d:%03d:%03d\n",$_/36e8,$_/6e7%60,$_/1e6%60,$_/1e3%1e3,$_%1e3'，甚至可以做得更短！
— hmatt1 2015年
您也不需要\n在输出字符串中。您也可以将字符串替换为"%02d:"x3 ."%03d:%03d"
— hmatt1
@chilemagic使用“ echo”是否算作字节增加？
— ASCIIThenANSI
@ASCIIThenANSI并不是因为它不是程序的一部分。您将要计算的字符是单引号之间的字符，即printf"%02d:%02d:%02d:%03d:%03d\n",$_/36e8,$_/6e7%60,$_/1e6%60,$_/1e3%1e3,$_‌​%1e3，然后为-n标志添加一个额外的字节。-nle例如，如果您使用，那将算作额外的2（对于n和l）。您可以免费获得-和和e（或E如果需要使用say）。
— hmatt1
1

Matlab-88 89字节

在不使用内置函数的情况下使用解决方案获得了一个字节：

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运算符组合完成字符串

— 保喜
source
1

的JavaScript（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);
展开摘要

— 溜冰场助理6
source
不需要进行第一次检查，因为问题很明显：0 <= n <= 86400000000
— edc65
@ edc65如果没有进行第一次检查，我只能得到0≤n <86400000000的范围，因为8.64e10会延续到第二天。
— rink.attendant.15年
哦，对了，我很想念。toJSON（）而不是toISOString（）？
— edc65
1

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;
}
— 安德里亚·比昂多（Andrea Biondo）
source
取决于平台，“长”可能只有32位。（请参见en.wikipedia.org/wiki/64-bit_computing#64-bit_data_models）。我通过将“ f”声明为宏而不是函数来避免了该问题。
— 一些用户
我注意到了。我在x64上使用了GCC，明天修复它。
— Andrea Biondo
0

CoffeeScript，127个字节

在ASCIIThenANSI的答案中采用了这种方法。JavaScript Console 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
— 溜冰场助理6
source
0

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)

用法

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
— 布拉布
source
0

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"
— 手工电子食品
source
0

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

它还使用嵌入式分配来计算使用浮点数转换的输入毫秒数（毫秒，秒，分钟和小时）。然后，使用模运算符（%）和十进制数字格式（%d）将printf()其强制为整数（小数部分将被忽略）。

使用日期函数的另一种解决方案（102字节）

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

hour：minutes：seconds部分由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
— 缺氧
source
0

Java，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));
}
— RCB
source
-1

Ruby-82字节

puts (t=Time.at(0,gets.to_i)).strftime("%2H:%2M:%2S:%3L:#{(t.usec%1000).to_s.rjust(3,?0)}")
— 异蟾蜍
source
2
但是我数了91个字节。它也仅适用于UTC时区。
— jimmy23013
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.