仕事

あらゆるタイプの並列化を使用して、少なくとも1分間（ただし1分半未満）の合計スリープ時間まで、複数の期間待機します。

プログラム/関数は、10秒以内に終了し、2つの値（すべての手段および形式）を返す必要があります。合計経過時間と実行された合計スリープ時間です。両方の時間値には、少なくとも0.1秒の精度が必要です。

これは工数の概念に似ています。60時間かかるジョブは、10人の作業者がジョブを分割している場合、わずか6時間で完了できます。ここでは、たとえば10個の並列スレッドで60秒のスリープ時間を設定できるため、ジョブ全体を完了するのに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：すべてのスレッドが完了するまで待機し、各スレッドの結果を取得します。
• (⌈/,+/)：1つのスレッドの最長実行時間（他のすべてのスレッドが終了したため、これが実際のランタイムです）に続いて、すべてのスレッドの実行時間の合計を返します。

オンラインでお試しください！

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）。各スレッドが9秒間スリープする8つのスレッドが作成され、リアルタイムランタイムは最大9秒、パラレルランタイムは最大72秒になります。

公式のドキュメントでは、Threadコンストラクターはキーワード引数で呼び出す必要があると書かれていますが、風に注意し、とにかく位置引数を使用します。最初の引数（group）はでなければならずNone、2番目の引数はターゲット関数です。

nneonneoは、属性アクセス（例f.t）がリスト索引アクセス（例t[0]）よりも短いことをコメントで指摘しました。残念ながら、ほとんどの場合、これを行うことで得られる数バイトは、実行時にユーザー定義の属性を作成できるオブジェクトを作成する必要があるため失われます。幸いなことに、関数は実行時にユーザー定義の属性をサポートしているため、のt属性の合計時間を節約することでこれを活用していますf。

オンラインで試す

-5バイトのDenkerAffeに感謝します execトリック。

スレッド引数が不要であることを指摘して、-7バイトのkundorに感謝します。

その他の改善による-7バイトのnneonneoに感謝します。

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プレフィックスを\。にすることにより、シェル組み込みの代わりに実行可能ファイルの使用を強制します。

ファイル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)}

出力（ミリ秒）：160.9939ミリ秒 、60001（60ミリ秒待機する160ミリ秒）

バッシュ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]));

7秒間で9回、合計63秒間（実際に試してみると63.43）待つことを約束しますが、実際に試してみると7.05秒の実時間しかかかりません。

C、127バイト（CPUをスピン）

このソリューションは、スリープする代わりにCPUをスピンし、timesPOSIX関数（親プロセスとすべての待機中の子で消費されるCPU時間を測定する）を使用して時間をカウントします。

毎回9秒間スピンする7つのプロセスを分岐し、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秒、合計CPU時間で63.47秒です。

最良の結果を得るには、-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（正確に）秒を取得します。

メインスレッドに-S戻り"Running"、ジョブがtatus である限り、空のwhileループ内でスピンします。それが完了したらGet-Job、既存のすべてのジョブのオブジェクトをReceive-Jobプルアップし、STDOUTに相当するもの（つまり、出力するもの）をプルアップするオブジェクト-join、結果をとともに+パイプし、パイプしますiex（Invoke-Expressionそして同様にeval）。これにより、結果のスリープ時間とオーバーヘッドが出力されます。

最後の行も同様です。新しい日付を取得し、元の日付スタンプを減算し$d、を取得して.Ticks、除算し1e7て合計実行時間を出力します。

NB

OK、だからこれはルールのややこしいです。PowerShellは、最初の実行時に、デフォルトのシェルプロファイルではロードされないため、さまざまなスレッド操作のためにディスクから多数の.NETアセンブリをロードする必要があるようです。アセンブリは既にメモリ内にあるため、その後の実行は正常に機能します。シェルウィンドウを十分長い間アイドル状態のままにすると、PowerShellの組み込みのガベージコレクションが取得されてアンロードされます、それらのすべてのアセンブリがれるため、次の実行で再ロードに時間がかかります。これを回避する方法がわかりません。

これは、以下の実行の実行時間で確認できます。新鮮なシェルを起動し、ゴルフディレクトリに移動して、スクリプトを実行しました。最初の実行は恐ろしいものでしたが、2番目の実行（すぐに実行）は正常に機能しました。その後、シェルを数分間アイドル状態にして、ガベージコレクションを実行します。その実行は再び長くなりますが、その後の実行は再び正常に機能します。

実行例

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バイト

このコードは、ロード時にそれぞれ6秒の間隔で10個の画像を作成します。

実行時間はそれより少し上になります（オーバーヘッドのため）。

このコードはドキュメント内のすべてを上書きします！

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秒未満で終了する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個の画像で600ms待機することです。これにより、大量のオーバーヘッドが発生します。

古いバージョン（203バイト）：

このコードは、10個のイメージを作成する代わりに、それぞれ6秒の時間間隔で10個のiframeを作成します。

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を生成します。これらはほとんどすべてが4ミリ秒の間隔で実行されます。

各間隔は、合計99の間隔で610ミリ秒です。

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

通常、610ms以内で実行され、合計実行時間は約60.5秒です。

これは、Google Chromeバージョン51.0.2704.84 m、Windows 8.1 x64でテストされました。

古いバージョン（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」というスプライトを使用します。スプライトはそれ自体のクローンを作成します。各クローンは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秒のDurationを取得することです。

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（ES6、WebWorkersを使用）、 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ではなくオブジェクトがまだある場合は動作しません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での動作がテストされています。

基本的に、親が8秒間スリープする間に7秒間スリープする9つのスレッドを分岐します。その後、時間を出力します。サンプル出力：

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のenv変数）= 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 /秒）であるため、プログラムは70秒間実行されました。

omp_get_wtime（）以外のタイマーを動作させる方法を考えた場合は、includeステートメントも削除できるため、はるかに短くなる可能性があります。

OMP_NUM_THREADS = 9で実行

Common 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で60秒）を超えるまで待機します。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、158 143文字

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を生成しTask、それらをマッピングすることでそれぞれを待機し、経過時間の合計を見つけます。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（2番目の引数）b、結果に適用します（1番目の引数）。

w スリープ機能です。

mainそれ自体が測定され、結果が出力されます（print!...）。

#is replicateM、指定されたアクションをN回繰り返します（そしてt、ゴルフのために戻ります）。

測定されたパーツ内で、9つのスレッド（replicate 9 $ forkIO ...）が5^10ミリ秒（9.765625秒）スリープwriteChanし、メインスレッド（newChan）によって作成されたパイプに結果（）をポストし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を使用）、123 116バイト

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

編集：histocratによる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で最も優れた名前の関数の1つです）。最後の行（総時間と実際の経過時間の配列）は、セミコロンで終了していないため出力されます。

ただし、これによりなんと9つの本格的なMATLABプロセスが作成されることに注意してください。この特定のプログラムは、マシンで割り当てられた10秒以内に終了しない可能性があります。ただし、SSDを搭載したハイエンドシステムにインストールされたParallel Computingツールボックス以外のツールボックスを持たないMATLABインストールでは、10秒以内に終了する可能性があります。必要に応じて、パラメータを微調整して、より少ないプロセスでより多くスリープ状態にすることができます。