任务

使用任何类型的并行化，请等待多个时间段，以使总睡眠时间至少为一分钟（但少于一分钟半）。

程序/功能必须在10秒内终止，并以任何方式（以任何方式）返回两个值：总经过时间和总执行睡眠时间。两个时间值都必须具有至少0.1秒的精度。

这类似于工时的概念：如果有10名工人分班工作，那么需要60个小时的工作只能在6个小时内完成。在这里，我们可以有60秒的睡眠时间，例如在10个并行线程中，因此只需要6秒就可以完成整个工作。

例

MyProgram程序创建14个线程，每个线程休眠5秒：

MyProgram → [5.016,70.105]

执行时间大于5秒，由于开销，总睡眠时间大于70秒。

Dyalog APL，65 27 23 21字节

(⌈/,+/)⎕TSYNC⎕DL&¨9/7

即：

      (⌈/,+/)⎕TSYNC⎕DL&¨9/7
7.022 63.162

说明：

• ⎕DL&¨9/7：分解9个线程，每个线程等待7秒。⎕DL返回实际花费的等待时间（以秒为单位），与参数的给定或花费数毫秒相同。
• ⎕TSYNC：等待所有线程完成，并获取每个线程的结果。
• (⌈/,+/)：返回单个线程的最长执行时间（在执行所有其他线程的过程中，这是实际的运行时间），然后是所有线程的执行时间之和。

在线尝试！

Python 2，172字节

import threading as H,time as T
m=T.time
z=H.Thread
s=m()
r=[]
def f():n=m();T.sleep(9);f.t+=m()-n
f.t=0
exec"r+=[z(None,f)];r[-1].start();"*8
map(z.join,r)
print m()-s,f.t

这要求时间精度大于1秒的OS才能正常工作（换句话说，是任何现代OS）。创建了8个线程，每个线程休眠9秒，从而导致约9秒的实时运行时间和约72秒的并行运行时间。

尽管官方文档说Thread应该使用关键字参数来调用构造函数，但我还是一意孤行，始终使用位置参数。第一个参数（group）必须为None，第二个参数为目标函数。

nneonneo在评论中指出，属性访问（例如f.t）比列表索引访问（例如t[0]）短。不幸的是，在大多数情况下，需要创建一个允许在运行时创建用户定义的属性的对象，这样做会损失掉几个字节。幸运的是，函数在运行时支持用户定义的属性，因此我通过将总时间保存在的t属性中来利用这一点f。

在线尝试

感谢DenkerAffe提供了-5个字节的exec技巧。

感谢kundor提供了-7个字节，它指出了thread参数是不必要的。

感谢nneonneo从其他改进中获得了-7个字节。

Bash + GNU实用程序，85

\time -f%e bash -c 'for i in {1..8};{ \time -aoj -f%e sleep 8&};wait'
paste -sd+ j|bc

强制使用time可执行文件，而不是通过在文件名前面加上内置的shell \。

附加到一个文件j，该文件在开始时必须为空或不存在。

Go-189字节

谢谢@cat！

package main
import(."fmt";."time");var m,t=60001,make(chan int,m);func main(){s:=Now();for i:=0;i<m;i++{go func(){Sleep(Millisecond);t<-0}()};c:=0;for i:=0;i<m;i++{c++};Print(Since(s),c)}

输出（ms）： 160.9939ms，60001（160ms等待60.001秒）

击196 117 114 93个字节

已更新，通过整合@manatwork和@Digital Trauma的建议以及其他一些空间优化来支持更好的时间精度：

d()(date +$1%s.%N;)
b=`d`
for i in {1..8};{ (d -;sleep 8;d +)>>j&}
wait
bc<<<`d`-$b
bc<<<`<j`

请注意，这假设j文件开头没有。

JavaScript（ES6），148个字节

with(performance)Promise.all([...Array(9)].map(_=>new Promise(r=>setTimeout(_=>r(t+=now()),7e3,t-=now())),t=0,n=now())).then(_=>alert([now()-n,t]));

答应等待9次，共7秒，总共63秒（我尝试时实际为63.43），但实际上我尝试时仅花费7.05秒的实时时间。

C，127字节（自旋CPU）

该解决方案使CPU旋转而不是休眠，并使用timesPOSIX函数（用于测量父进程和所有等待的子进程消耗的CPU时间）对时间进行计数。

它分叉7个进程，每个进程旋转9秒，并以C时钟输出最终时间（在大多数系统上，100个时钟滴答= 1秒）。

t;v[4];main(){fork(fork(fork(t=time(0))));while(time(0)<=t+9);wait(0);wait(0);wait(0)>0&&(times(v),printf("%d,%d",v[0],v[2]));}

样本输出：

906,6347

表示9.06秒的实时时间和63.47秒的总CPU时间。

为了获得最佳结果，请使用编译-std=c90 -m32（在64位计算机上强制使用32位代码）。

PowerShell v4，144字节

$d=date;gjb|rjb
1..20|%{sajb{$x=date;sleep 3;((date)-$x).Ticks/1e7}>$null}
while(gjb -s "Running"){}(gjb|rcjb)-join'+'|iex
((date)-$d).Ticks/1e7

设置$d等于Get-Date，并使用清除所有现有的工作历史记录Get-Job | Remove-Job。然后1..20|%{...}，我们循环并执行每次迭代，将作业Start-Job的脚本块传递给它{$x=date;sleep 3;((date)-$x).ticks/1e7}（这意味着每个作业将执行该脚本块）。我们将输出通过管道传递到管道，>$null以抑制返回的反馈（例如，工作名称，状态等）。

脚本块设置$x为Get-Date，然后Start-Sleep持续3几秒钟，然后Get-Date读取新的读数，减去$x，得到.Ticks，然后除以1e7得到秒（精确）。

回到主线程中，只要任何作业仍然是-Status "Running"，我们就在一个空while循环内旋转。完成此操作后，我们Get-Job将为所有现有作业拉出对象Receive-Job，将将与STDOUT等效的对象（即，它们输出的内容）-join通过+管道传递给对象，并将结果与​​一起通过管道传递给iex（Invoke-Expression和相似eval）。这将输出结果睡眠时间和开销。

最后一行是相似的，它得到一个新日期，减去原始日期戳$d，得到.Ticks，然后除以1e7输出总执行时间。

NB

好的，所以这有点不明智。显然，在第一次执行时，PowerShell需要从磁盘加载一堆.NET程序集以执行各种线程操作，因为它们没有使用默认的shell配置文件加载。由于程序集已经在内存中，因此后续执行可以正常工作。如果您将Shell窗口闲置足够长的时间，则将获得PowerShell的内置垃圾收集来卸载所有这些程序集，从而导致下一次执行需要很长时间才能重新加载它们。我不确定是否可以解决此问题。

您可以在以下运行的执行时间中看到这一点。我重新启动外壳，导航到我的高尔夫球目录，并执行了脚本。第一次运行很可怕，但是第二次（立即执行）运行良好。然后，我将外壳闲置了几分钟，以进行垃圾收集，然后该运行又很漫长，但随后的运行又可以正常进行了。

运行示例

Windows PowerShell
Copyright (C) 2014 Microsoft Corporation. All rights reserved.

PS H:\> c:

PS C:\> cd C:\Tools\Scripts\golfing

PS C:\Tools\Scripts\golfing> .\wait-a-minute.ps1
63.232359
67.8403415

PS C:\Tools\Scripts\golfing> .\wait-a-minute.ps1
61.0809705
8.8991164

PS C:\Tools\Scripts\golfing> .\wait-a-minute.ps1
62.5791712
67.3228933

PS C:\Tools\Scripts\golfing> .\wait-a-minute.ps1
61.1303589
8.5939405

PS C:\Tools\Scripts\golfing> .\wait-a-minute.ps1
61.3210352
8.6386886

PS C:\Tools\Scripts\golfing>

Javascript（ES6）， 212 203 145字节

此代码在加载时创建10张图像，每张图像的时间间隔分别为6秒。

执行时间比它高出一点点（由于开销）。

此代码将覆盖文档中的所有内容！

P=performance,M=P.now(T=Y=0),document.body.innerHTML='<img src=# onerror=setTimeout(`T+=P.now()-M,--i||alert([P.now()-M,T])`,6e3) >'.repeat(i=10)

假定您对反引号使用单字节编码，这是Javascript引擎不跳闸所必需的。

或者，如果您不想花6秒钟的时间等待，那么可以使用一个长1字节的解决方案，该解决方案可以在不到一秒钟的时间内完成：

P=performance,M=P.now(T=Y=0),document.body.innerHTML='<img src=# onerror=setTimeout(`T+=P.now()-M,--i||alert([P.now()-M,T])`,600) >'.repeat(i=100)

不同之处在于此代码在100张图像中等待600毫秒。这将产生大量开销。

旧版本（203字节）：

此代码创建10个iframe，每个时间间隔恰好为6秒，而不是创建10张图像。

for(P=performance,M=P.now(T=Y=i=0),D=document,X=_=>{T+=_,--i||alert([P.now()-M,T])};i<10;i++)I=D.createElement`iframe`,I.src='javascript:setTimeout(_=>top.X(performance.now()),6e3)',D.body.appendChild(I)

原始版本（212字节）：

P=performance,M=P.now(T=Y=0),D=document,X=_=>{T+=_,Y++>8&&alert([P.now()-M,T])},[...''+1e9].map(_=>{I=D.createElement`iframe`,I.src='javascript:setTimeout(_=>top.X(performance.now()),6e3)',D.body.appendChild(I)})

露比（92）

n=->{Time.now}
t=n[]
a=0
(0..9).map{Thread.new{b=n[];sleep 6;a+=n[]-b}}.map &:join
p n[]-t,a

Javascript（ES6）， 108 92字节

我要提出一个新的答案，因为这样做使用的方式略有不同。

它生成大量的setTimeouts，几乎所有s都在它们之间以4ms执行。

每个间隔为610毫秒，共计99个间隔。

M=(N=Date.now)(T=Y=0),eval('setTimeout("T+=N()-M,--i||alert([N()-M,T])",610);'.repeat(i=99))

它通常在610毫秒内运行，总执行时间约为60.5秒。

已在Windows 8.1 x64的Google Chrome版本51.0.2704.84 m上进行了测试。

旧版本（108字节）：

P=performance,M=P.now(T=Y=0),eval('setTimeout("T+=P.now()-M,--i||alert([P.now()-M,T])",610);'.repeat(i=99))

从头开始-164字节（16块）

when gf clicked
set[t v]to[
repeat(9
  create clone of[s v
end
wait until<(t)>[60
say(join(join(t)[ ])(timer
when I start as a clone
wait(8)secs
change[t v]by(timer

看到它在这里行动。

使用一个名为“ t”的变量和一个名为“ s”的精灵。Sprite会创建其自身的克隆，每个克隆等待8秒，并递增一个变量来计时整个等待时间。最后，它表示总执行时间和总等待时间（例如65.488 8.302）。

Clojure， 135 120 111 109字节

(let[t #(System/nanoTime)s(t)f #(-(t)%)][(apply +(pmap #(let[s(t)](Thread/sleep 7e3)%(f s))(range 9)))(f s)])

带有命名变量的格式化版本：

(let [time #(System/currentTimeMillis)
      start (time)
      fmt #(- (time) %)]
  [(apply +
           (pmap #(let [thread-start (time)]
                   (Thread/sleep 7e3)
                   %
                   (fmt thread-start)) (range 9)))
   (fmt start)])

输出（以纳秒为单位）：

[62999772966 7001137032]

格式更改。感谢Adám，当我阅读该格式规范时，可能会错过该格式规范。

更改为nanoTime以提高高尔夫能力。

感谢悬崖根，我完全忘记了科学计数法，简直不敢相信我没有看到apply。我想我在昨天打高尔夫球但从未发布过的东西中使用了它。您为我节省了2个字节。

锈，257，247个字节

我使用与Mego的Python答案相同的时间。

确实，只有一点点聪明的地方就是使用ii来获得持续时间0秒。

fn main(){let n=std::time::Instant::now;let i=n();let h:Vec<_>=(0..8).map(|_|std::thread::spawn(move||{let i=n();std::thread::sleep_ms(9000);i.elapsed()})).collect();let mut t=i-i;for x in h{t+=x.join().unwrap();}print!("{:?}{:?}",t,i.elapsed());}

印刷品：

Duration { secs: 71, nanos: 995877193 }Duration { secs: 9, nanos: 774491 }

取消高尔夫：

fn main(){
    let n = std::time::Instant::now;
    let i = n();
    let h :Vec<_> =
        (0..8).map(|_|
            std::thread::spawn(
                move||{
                    let i = n();
                    std::thread::sleep_ms(9000);
                    i.elapsed()
                }
            )
        ).collect();
    let mut t=i-i;
    for x in h{
        t+=x.join().unwrap();
    }
    print!("{:?}{:?}",t,i.elapsed());
}

编辑：好旧的循环有点短

JavaScript（使用WebWorkers的ES6）， 233 215字节

c=s=0;d=new Date();for(i=14;i-->0;)(new Worker(URL.createObjectURL(new Blob(['a=new Date();setTimeout(()=>postMessage(new Date()-a),5e3)'])))).onmessage=m=>{s+=m.data;if(++c>13)console.log((new Date()-d)/1e3,s/1e3)}

UPD：在跨域策略方面，用更紧凑和跨浏览器的字符串代替了从字符串执行工作者的方式。如果Safari 和IE中仍然有webkitURL对象代替，则无法在Safari URL中使用。

Python 2，130字节

import thread as H,time as T
m=T.clock;T.z=m()
def f(k):T.sleep(k);T.z+=m()
exec"H.start_new_thread(f,(7,));"*9
f(8);print m(),T.z

这是对Mego答案的推导，但与我认为应该作为单独答案的足够不同。经过测试，可以在Windows上运行。

基本上，它派生出9个线程，这些线程休眠7秒钟，而父线程则休眠8个线程。然后打印出时间。样本输出：

8.00059192923 71.0259046024

在Windows上，time.clock测量自首次呼叫以来的挂墙时间。

Perl 6，72 71字节

可能有一种更短的方法

say sum await map {start {sleep 7;now -ENTER now}},^9;say now -INIT now

这个输出

63.00660729694
7.0064013

Mathematica，109个字节

a=AbsoluteTiming;LaunchKernels@7;Plus@@@a@ParallelTable[#&@@a@Pause@9,{7},Method->"EvaluationsPerKernel"->1]&

匿名函数。需要具有7个以上子内核的许可证才能运行。花费9秒钟的实时时间和63秒钟的内核时间，这不算开销。确保只运行前面的语句一次（因此它不会尝试重新启动内核）。测试：

In[1]:= a=AbsoluteTiming;LaunchKernels@7;func=Plus@@@a@ParallelTable[#&@@a@Pause
@9,{7},Method->"EvaluationsPerKernel"->1]&;

In[2]:= func[]

Out[2]= {9.01498, 63.0068}

In[3]:= func[]

Out[3]= {9.01167, 63.0047}

In[4]:= func[]

Out[4]= {9.00587, 63.0051}

Javascript（ES6），105个字节

((t,c,d)=>{i=t();while(c--)setTimeout((c,s)=>{d+=t()-s;if(!c)alert([t()-i,d])},8e3,c,t())})(Date.now,8,0)

更新版本：106字节 从@Ismael Miguel借来的，因为他有个很棒的主意，可以减少睡眠时间并增加间隔时间。

((t,c,d)=>{i=t();while(c--)setTimeout((c,s)=>{d+=t()-s;if(!c)alert([t()-i,d])},610,c,t())})(Date.now,99,0)

Javascript Ungolfed，167个字节

(function(t, c, d){
	i = t();
	while(c--){
		setTimeout(function(c, s){
			d += t() - s;
			if (!c) alert([t() - i, d])
		}, 8e3, c, t())
	}
})(Date.now, 8, 0)

Java中，358个343 337 316 313字节

import static java.lang.System.*;class t extends Thread{public void run(){long s=nanoTime();try{sleep(999);}catch(Exception e){}t+=nanoTime()-s;}static long t,i,x;public static void main(String[]a)throws Exception{x=nanoTime();for(;++i<99;)new t().start();sleep(9000);out.println((nanoTime()-x)/1e9+" "+t/1e9);}}

而且没有高尔夫球

import static java.lang.System.*;

class t extends Thread {
    public void run() {
        long s = nanoTime();
        try {
            sleep(999);
        } catch (Exception e) {
        }
        t += nanoTime() - s;
    }

    static long t,i,x;

    public static void main(String[] a) throws Exception {
        x = nanoTime();
        for (; ++i < 99;)
            new t().start();
        sleep(9000);
        out.println((nanoTime() - x) / 1e9 + " " + t / 1e9);
    }
}

请不要在家尝试，因为此解决方案不是线程安全的。

编辑：

我接受了@A Boschman和@Adám的建议，现在我的程序运行时间不到10秒，并且缩短了15个字节。

C（带有pthread）， 339 336 335字节

#include<stdio.h>
#include<sys/time.h>
#include<pthread.h>
#define d double
d s=0;int i;pthread_t p[14];d t(){struct timeval a;gettimeofday(&a,NULL);return a.tv_sec+a.tv_usec/1e6;}
h(){d b=t();sleep(5);s+=t()-b;}
main(){d g=t();for(i=14;i-->0;)pthread_create(&p[i],0,&h,0);for(i=14;i-->0;)pthread_join(p[i],0);printf("%f %f",t()-g,s);}

C90（OpenMP），131字节（+ 17表示环境变量）= 148字节

#include <omp.h>
#define o omp_get_wtime()
n[4];main(t){t=o;
#pragma omp parallel
while(o-9<t);times(n);printf("%d,%f",n[0],o-t);}

示例输出：

7091,9.000014

笔记：

7091处于循环状态（100 / sec），因此程序运行了70秒

如果我找到了一种使计时器工作的方法而不是omp_get_wtime（），则可能会更短，因为这样我也可以删除include语句。

以OMP_NUM_THREADS = 9运行

通用Lisp（SBCL）166字节：

(do((m #1=(get-internal-real-time))(o(list 0)))((>(car o)60000)`(,(car o),(- #1#m)))(sb-thread:make-thread(lambda(&aux(s #1#))(sleep 1)(atomic-incf(car o)(- #1#s)))))

这只是产生了休眠的线程，然后以原子方式增加了所花费的时间，而一个外循环则旋转，等待总时间超过60000滴答（即sbcl上为60s）。由于对atomic-incf可以修改的位置类型的限制，该计数器存储在列表中。在终止速度更快的计算机之前，这可能会耗尽空间。

取消高尔夫：

(do ((outer-start (get-internal-real-time))
       (total-inner (list 0)))
      ((> (car total-inner) 60000)
       `(,(car total-inner)
      ,(- (get-internal-real-time) outer-start)))
    (sb-thread:make-thread
     (lambda (&aux(start (get-internal-real-time)))
       (sleep 1)
       (atomic-incf (car total-inner) (- (get-internal-real-time) start)))))

Perl，101个字节

use Time::HiRes<time sleep>;pipe*1=\time,0;
print time-$1,eval<1>if open-print{fork&fork&fork}-sleep 9

分叉7个子进程，每个子进程等待9秒。

样本输出：

perl wait-one-minute.pl
9.00925707817078-63.001741

Groovy，158143个字符

d={new Date().getTime()}
s=d(j=0)
8.times{Thread.start{b=d(m=1000)
sleep 8*m
synchronized(j){j+=d()-b}}}addShutdownHook{print([(d()-s)/m,j/m])}

样品运行：

bash-4.3$ groovy wait1minute.groovy
[8.031, 64.055]

Elixir，168个字节

import Task;import Enum;IO.puts elem(:timer.tc(fn->IO.puts(map(map(1..16,fn _->async(fn->:timer.tc(fn->:timer.sleep(4000)end)end)end),&(elem(await(&1),0)))|>sum)end),0)

样品运行：

$ elixir thing.exs
64012846
4007547

输出是等待的总时间，然后是程序运行的时间（以微秒为单位）。

程序产生14 Tasks，并通过映射它们来等待它们中的每一个，然后找到它们经过时间的总和。它使用Erlang timer来测量时间。

Haskell中，278个 271 262 246字节

import Control.Concurrent.Chan
import Data.Time
import GHC.Conc
t=getCurrentTime
b!a=b=<<flip diffUTCTime<$>t<*>(a>>t)
w=threadDelay$5^10
0#_=t
i#a=a>>(i-1)#a
main=print!do r<-newChan;9#(forkIO$writeChan r!w);getChanContents r>>=print.sum.take 9

!测量操作a（第二个参数）所花费的时间，并将结果b（第一个参数）应用于结果。

w 是睡眠功能。

main本身进行测量，并打印结果（print!...）。

#是replicateM，将给定的动作重复N次（并且t由于打高尔夫球而返回）。

在被测零件内部，9个线程（replicate 9 $ forkIO ...）睡眠数5^10毫秒（9.765625秒），并将结果（writeChan）发布到由主线程（newChan）创建的管道中，该管道将9个结果相加并打印总计（getChanContents >>= print . sum . take 9）。

输出：

87.938546708s
9.772032144s

Python 2，132字节

使用一个进程池生成9个进程，并使每个进程休眠7秒。

import time as t,multiprocessing as m
def f(x):d=s();t.sleep(x);return s()-d
s=t.time
a=s()
print sum(m.Pool(9).map(f,[7]*9)),s()-a

首先打印总的累积睡眠时间，然后打印实际运行时间：

$ python test.py
63.0631158352 7.04391384125

Ruby（含parallelgem），123116字节

require'parallel'
n=->{Time.now}
t=n[]
q=0
Parallel.each(1..10,:in_threads=>10){z=n[];sleep 6;q+=n[]-z}
puts n[]-t,q

编辑：从historcrat的Ruby回答中添加了“ Time.now”引用。

Matlab，75个字节

tic;parpool(9);b=1:9;parfor q=b
a=tic;pause(7);b(q)=toc(a);end
[sum(b);toc]

快速说明：parfor创建一个并行的for循环，分布在整个工作池中。tic并toc测量经过的时间（在我看来，这是MATLAB中最佳命名的函数之一）。由于没有以分号结尾，因此输出了最后一行（总睡眠时间和实际时间经过的数组）。

但是请注意，这将创建多达9个完整的MATLAB进程。这样一来，此特定程序就有可能在您的计算机上分配的10秒内无法完成。但是，我认为在没有工具箱的MATLAB安装中，除了安装了Parallel Computing工具箱（安装在具有SSD的高端系统上）之外，它可能只能在10秒内完成。如果需要，您可以调整参数以使更少的进程睡眠更多。