Bài tập, nhiệm vụ

Sử dụng bất kỳ loại song song nào, chờ nhiều thời gian, trong tổng thời gian ngủ ít nhất một phút (nhưng ít hơn một phút rưỡi).

Chương trình / chức năng phải chấm dứt trong vòng 10 giây và trả về (bằng bất kỳ phương tiện nào và ở bất kỳ định dạng nào) hai giá trị: tổng thời gian đã trôi qua và tổng thời gian ngủ được thực hiện. Cả hai giá trị thời gian phải có độ chính xác ít nhất 0,1 giây.

Điều này tương tự như khái niệm về giờ làm việc: một công việc mất 60 giờ có thể hoàn thành chỉ trong 6 giờ nếu 10 công nhân đang chia tách công việc. Ở đây chúng ta có thể có 60 giây thời gian ngủ, ví dụ như trong 10 luồng song song, do đó chỉ cần 6 giây để hoàn thành toàn bộ công việc.

Thí dụ

Chương trình MyProgram tạo ra 14 luồng, mỗi luồng ngủ trong 5 giây:

MyProgram → [5.016,70.105]

Thời gian thực hiện lớn hơn 5 giây và tổng thời gian ngủ lớn hơn 70 giây vì chi phí hoạt động.

APL Dyalog, 65 27 23 21 byte

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

I E:

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

Giải trình:

• ⎕DL&¨9/7: quay ra 9 luồng, mỗi luồng chờ trong 7 giây. ⎕DLtrả về lượng thời gian thực tế chờ đợi, tính bằng giây, sẽ giống như đối số của nó đưa ra hoặc mất vài mili giây.
• ⎕TSYNC: chờ cho tất cả các luồng hoàn thành và nhận kết quả cho từng luồng.
• (⌈/,+/): trả về thời gian thực hiện dài nhất của một luồng (trong khi thực hiện tất cả các luồng khác đã hoàn thành, vì vậy đây là thời gian chạy thực tế), tiếp theo là tổng thời gian thực hiện của tất cả các luồng.

Hãy thử trực tuyến!

Python 2, 172 byte

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

Điều này đòi hỏi một HĐH có độ chính xác về thời gian lớn hơn 1 giây để hoạt động chính xác (nói cách khác, bất kỳ HĐH hiện đại nào). 8 luồng được tạo trong đó ngủ trong 9 giây, dẫn đến thời gian thực là ~ 9 giây và thời gian chạy song song là ~ 72 giây.

Mặc dù tài liệu chính thức nói rằng hàm Threadtạo nên được gọi bằng các đối số từ khóa, tôi vẫn thận trọng và sử dụng các đối số vị trí. Đối số thứ nhất ( group) phải là Nonevà đối số thứ hai là hàm mục tiêu.

nneonneo đã chỉ ra trong các ý kiến ​​rằng quyền truy cập thuộc tính (ví dụ f.t) ngắn hơn quyền truy cập chỉ mục danh sách (ví dụ t[0]). Thật không may, trong hầu hết các trường hợp, một vài byte thu được từ việc này sẽ bị mất bằng cách cần tạo một đối tượng cho phép các thuộc tính do người dùng định nghĩa được tạo khi chạy. May mắn thay, các hàm hỗ trợ các thuộc tính do người dùng xác định trong thời gian chạy, vì vậy tôi khai thác điều này bằng cách tiết kiệm tổng thời gian trong tthuộc tính của f.

Dùng thử trực tuyến

Cảm ơn DenkerAffe cho -5 byte với execthủ thuật.

Nhờ kundor cho -7 byte bằng cách chỉ ra rằng đối số luồng là không cần thiết.

Nhờ nneonneo cho -7 byte từ các cải tiến linh tinh.

Tiện ích Bash + GNU, 85

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

Buộc sử dụng timetệp thực thi thay vì shell dựng sẵn bằng cách thêm tiền tố vào a \.

Nối vào một tệp j, phải trống hoặc không tồn tại khi bắt đầu.

Đi - 189 byte

Cảm ơn @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)}

Đầu ra (ms): 160,9939ms, 60001 ( 160ms để chờ 60,001 giây)

Bash 196 117 114 93 byte

Được cập nhật để hỗ trợ độ chính xác về thời gian tốt hơn bằng cách tích hợp các đề xuất từ ​​@manatwork và @Digital Trauma cũng như một vài tối ưu hóa không gian khác:

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

Lưu ý rằng điều này giả định rằng jtập tin vắng mặt lúc đầu.

JavaScript (ES6), 148 byte

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

Hứa sẽ đợi 9 lần trong 7 giây trong tổng số 63 giây (thực tế là 63,43 khi tôi thử), nhưng thực tế chỉ mất 7,05 giây thời gian thực khi tôi thử.

C, 127 byte (quay CPU)

Giải pháp này sẽ quay CPU thay vì ngủ và đếm thời gian bằng cách sử dụng timeschức năng POSIX (đo thời gian CPU được tiêu thụ bởi quá trình cha mẹ và trong tất cả trẻ em chờ đợi).

Nó loại bỏ 7 quy trình quay trong 9 giây và in ra lần cuối cùng trong đồng hồ C (trên hầu hết các hệ thống, 100 đồng hồ tích tắc = 1 giây).

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

Đầu ra mẫu:

906,6347

nghĩa là thời gian thực 9.06 giây và tổng thời gian CPU là 63,47 giây.

Để có kết quả tốt nhất, hãy biên dịch với -std=c90 -m32(buộc mã 32 bit trên máy 64 bit).

PowerShell v4, 144 byte

$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

Đặt $dbằng Get-Datevà xóa mọi lịch sử công việc hiện có với Get-Job | Remove-Job. Sau đó chúng ta lặp 1..20|%{...}và mỗi lần lặp thực thi Start-Jobchuyển qua khối kịch bản lệnh {$x=date;sleep 3;((date)-$x).ticks/1e7}cho công việc (nghĩa là mỗi công việc sẽ thực thi khối kịch bản lệnh đó). Chúng tôi đưa ra kết quả đầu ra để >$nullngăn chặn phản hồi (ví dụ: tên công việc, trạng thái, v.v.) được trả về.

Khối tập lệnh được đặt $xthành Get-Date, sau đó Start-Sleeptrong 3vài giây, sau đó lấy một lần Get-Dateđọc mới , trừ $x, lấy .Ticksvà chia 1e7cho để có được giây (với độ chính xác).

Quay lại chủ đề chính, miễn là mọi công việc vẫn còn là dấu -Svết "Running", chúng ta sẽ quay vòng trong một whilevòng lặp trống . Khi đã xong, chúng ta Get-Jobsẽ kéo các đối tượng cho tất cả các công việc hiện có, đưa các đối tượng Receive-Jobđó sẽ kéo lên tương đương với STDOUT (nghĩa là những gì chúng tạo ra), -joinkết quả cùng với +và chuyển nó sang iex( Invoke-Expressionvà tương tự eval). Điều này sẽ tạo ra thời gian ngủ kết quả cộng với chi phí.

Dòng cuối cùng là tương tự, trong đó nó có một ngày mới, trừ dấu ngày ban đầu $d, lấy .Ticksvà chia 1e7cho đầu ra tổng thời gian thực hiện.

Lưu ý

OK, vì vậy đây là một chút uốn cong của các quy tắc. Rõ ràng trong lần thực hiện đầu tiên, PowerShell cần tải một loạt các cụm .NET từ đĩa cho các hoạt động luồng khác nhau vì chúng không được tải với cấu hình shell mặc định. Các lần thực hiện tiếp theo , vì các hội đồng đã có trong bộ nhớ, hoạt động tốt. Nếu bạn để cửa sổ vỏ không đủ lâu, bạn sẽ có bộ sưu tập rác tích hợp của PowerShell đi cùng và dỡ tất cả các cụm đó, khiến lần thực thi tiếp theo mất nhiều thời gian khi tải lại chúng. Tôi không chắc chắn về cách này.

Bạn có thể thấy điều này trong thời gian thực hiện trong các lần chạy dưới đây. Tôi bắt đầu một lớp vỏ mới, điều hướng đến thư mục chơi gôn của mình và thực hiện kịch bản. Lần chạy đầu tiên rất khủng khiếp, nhưng lần thứ hai (được thực hiện ngay lập tức) hoạt động tốt. Sau đó tôi để cái vỏ nhàn rỗi trong vài phút để cho bộ sưu tập rác đi qua, và sau đó lần chạy đó lại kéo dài, nhưng các lần chạy tiếp theo lại hoạt động tốt.

Ví dụ chạy

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 byte

Mã này tạo ra 10 hình ảnh với khoảng thời gian chính xác là 6 giây mỗi lần, khi tải.

Thời gian thực hiện vượt quá một chút so với nó (do chi phí hoạt động).

Mã này ghi đè lên mọi thứ trong tài liệu!

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)

Điều này giả định rằng bạn sử dụng mã hóa một byte cho backticks, được yêu cầu để công cụ Javascript không bị vấp.

Alternativelly, nếu bạn không muốn mất 6 giây chờ đợi, đây là giải pháp dài hơn 1 byte kết thúc sau chưa đầy một giây:

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)

Sự khác biệt là mã này chờ 600ms trên 100 hình ảnh. Điều này sẽ cung cấp một lượng lớn đạn trên đầu.

Phiên bản cũ (203 byte):

Mã này tạo ra 10 iframe với khoảng thời gian chính xác là 6 giây, thay vì tạo 10 hình ảnh.

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)

Phiên bản gốc (212 byte):

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

Ruby, 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 byte

Tôi đang đưa ra một câu trả lời mới vì điều này sử dụng một aproach hơi khác.

Nó tạo ra một lượng lớn setTimeouts, gần như tất cả được thực hiện với 4ms giữa chúng.

Mỗi khoảng là 610 mili giây, trên tổng số 99 khoảng.

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

Nó thường chạy trong vòng 610ms, với tổng thời gian thực hiện khoảng 60,5 giây.

Điều này đã được thử nghiệm trên Google Chrome phiên bản 51.0.2704.84 m, trên windows 8.1 x64.

Phiên bản cũ (108 byte):

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

Cào - 164 byte (16 khối)

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

Xem nó trong hành động ở đây .

Sử dụng một biến gọi là 't' và một sprite gọi là 's'. Sprite tạo bản sao của chính nó, mỗi bản sao chờ 8 giây và tăng một biến số theo dõi toàn bộ thời gian chờ. Cuối cùng, nó cho biết tổng thời gian thực hiện và tổng thời gian chờ (ví dụ 65.488 8.302:).

Clojure, 135 120 111 109 byte

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

Phiên bản được định dạng với các biến được đặt tên:

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

đầu ra (tính bằng nano giây):

[62999772966 7001137032]

Thay đổi định dạng. Cảm ơn Adám, tôi có thể đã bỏ lỡ đặc tả định dạng đó trong câu hỏi khi tôi đọc nó.

Thay đổi thành nanoTime cho khả năng chơi gôn.

Cảm ơn cliffroot, tôi hoàn toàn quên mất ký hiệu khoa học và không thể tin rằng tôi đã không nhìn thấy apply. Tôi nghĩ rằng tôi đã sử dụng nó trong một cái gì đó tôi đã chơi golf ngày hôm qua nhưng không bao giờ được đăng. Bạn đã lưu cho tôi 2 byte.

Rust, 257 , 247 byte

Tôi sử dụng cùng thời gian với câu trả lời Python của Mego.

Thực sự chỉ có một chút thông minh là sử dụng ii để có Thời lượng 0 giây.

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

Bản in:

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

Ung dung:

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

Chỉnh sửa: vòng lặp cũ tốt hơn một chút

JavaScript (ES6, sử dụng WebWorkers), 233 215 byte

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

CẬP NHẬT: thay thế cách một công nhân được thực thi từ một chuỗi bằng một trình duyệt nhỏ gọn hơn và nhiều trình duyệt hơn, trong khía cạnh của các chính sách nguồn gốc chéo. Sẽ không hoạt động trong Safari, nếu nó vẫn có webkitURLđối tượng thay vì URLvà trong IE.

Python 2, 130 byte

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

Đây là một dẫn xuất của câu trả lời của Mego, nhưng nó đủ khác biệt đến mức tôi nghĩ nó nên là một câu trả lời riêng biệt. Nó được thử nghiệm để hoạt động trên Windows.

Về cơ bản, nó tách ra 9 luồng, ngủ trong 7 giây trong khi cha mẹ ngủ được 8. Sau đó, nó in ra thời gian. Đầu ra mẫu:

8.00059192923 71.0259046024

Trên Windows, time.clockđo thời gian treo tường kể từ cuộc gọi đầu tiên.

Perl 6, 72 71 byte

Có thể có một cách ngắn hơn để làm điều này

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

đầu ra này

63.00660729694
7.0064013

Toán học, 109 byte

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

Chức năng ẩn danh. Yêu cầu giấy phép có 7+ hạt nhân để chạy. Mất 9 giây thời gian thực và 63 giây thời gian hạt nhân, không chiếm chi phí. Đảm bảo chỉ chạy các câu lệnh trước một lần (vì vậy nó không cố khởi chạy lại hạt nhân). Kiểm tra:

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 byte

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

Phiên bản cập nhật: 106 byte Mượn từ @Ismael Miguel vì anh ấy có ý tưởng tuyệt vời để giảm thời gian ngủ và tăng khoảng thời gian.

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

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

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

và vô lương tâm

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

xin vui lòng không thử nó ở nhà, vì giải pháp này không phải là chủ đề an toàn.

Biên tập:

Tôi đã lấy các đề xuất của @A Boschman và @ Adám, và bây giờ chương trình của tôi cần ít hơn 10 giây để chạy và nó ngắn hơn 15 byte.

C (với pthreads), 339 336 335 byte

#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 Byte (+ 17 cho biến env) = 148 Byte

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

Kết quả ví dụ:

7091,9.000014

Ghi chú:

7091 đang trong chu kỳ (100 / giây), vì vậy chương trình đã chạy trong 70 giây

Có thể ngắn hơn nhiều nếu tôi tìm ra cách để bộ hẹn giờ hoạt động khác ngoài omp_get_wtime () vì sau đó tôi có thể xóa câu lệnh bao gồm.

Chạy với OMP_NUM_THREADS = 9

Lisp chung (SBCL) 166 byte:

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

Điều này chỉ sinh ra các luồng ngủ và sau đó tăng thời gian một cách nguyên tử, với một vòng ngoài xoay tròn chờ tổng thời gian là hơn 60000 tick (tức là 60 giây trên sbcl). Bộ đếm được lưu trữ trong một danh sách do những hạn chế đối với các loại địa điểm nguyên tử-incf có thể sửa đổi. Điều này có thể hết dung lượng trước khi kết thúc trên các máy nhanh hơn.

Ung dung:

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

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

Fork 7 tiến trình con, mỗi tiến trình chờ 9 giây.

Đầu ra mẫu:

perl wait-one-minute.pl
9.00925707817078-63.001741

Groovy, 158 143 ký tự

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

Chạy mẫu:

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

Thuốc tiên, 168 byte

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)

Chạy mẫu:

$ elixir thing.exs
64012846
4007547

Đầu ra là tổng thời gian chờ theo sau là thời gian chương trình đã chạy, tính bằng micro giây.

Chương trình sinh ra 14 Taskgiây và chờ đợi từng người trong số họ bằng cách ánh xạ qua chúng, và sau đó tìm thấy tổng thời gian đã trôi qua của họ. Nó sử dụng Erlang timerđể đo thời gian.

Haskell, 278 271 262 246 byte

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

!đo thời gian thực hiện bằng hành động a(đối số thứ hai) và áp dụng b(đối số thứ nhất) cho kết quả.

w là chức năng ngủ.

mainđược đo chính nó, và kết quả được in ( print!...).

#là replicateM, lặp lại hành động đã cho N lần (và quay lại tvì chơi golf).

Bên trong phần được đo, 9 luồng ( replicate 9 $ forkIO ...) ngủ trong một 5^10phần nghìn giây (9.765625 giây) và gửi kết quả ( writeChan) lên một đường ống được tạo bởi luồng chính ( newChan), tổng hợp 9 kết quả lên và in tổng ( getChanContents >>= print . sum . take 9).

Đầu ra:

87.938546708s
9.772032144s

Python 2, 132 byte

Sử dụng nhóm quy trình để sinh ra 9 quy trình và để mỗi người ngủ trong 7 giây.

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

In tổng số thời gian tích lũy trước, sau đó là thời gian chạy thực tế:

$ python test.py
63.0631158352 7.04391384125

Ruby (với parallelđá quý), 123 116 byte

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

Chỉnh sửa: Đã thêm tham chiếu "Time.now" từ câu trả lời Ruby của histocrat.

Matlab, 75 byte

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

Giải thích nhanh: parfortạo ra một vòng lặp for song song, phân bổ trên nhóm công nhân. ticvà tocđo thời gian trôi qua (và theo tôi là một trong những hàm được đặt tên tốt nhất trong MATLAB). Dòng cuối cùng (một mảng với tổng thời gian đã ngủ và thời gian thực trôi qua) được xuất ra do nó không bị chấm dứt bằng dấu chấm phẩy.

Tuy nhiên, lưu ý rằng điều này tạo ra 9 quy trình MATLAB chính thức. Rất có thể chương trình cụ thể này sẽ không hoàn thành trong vòng 10 giây được phân bổ trên máy của bạn. Tuy nhiên, tôi nghĩ rằng với bản cài đặt MATLAB không có hộp công cụ ngoại trừ hộp công cụ Tính toán song song được cài đặt - được cài đặt trên hệ thống cao cấp có SSD - có thể chỉ có thể hoàn thành trong vòng 10 giây. Nếu được yêu cầu, bạn có thể điều chỉnh các tham số để có ít quá trình ngủ nhiều hơn.