Tunggu sebentar - dalam waktu kurang dari sepuluh detik

69

Tugas

Dengan menggunakan semua jenis parallelisation, tunggu beberapa periode, untuk total waktu tidur setidaknya satu menit (tetapi kurang dari satu setengah menit).

Program / fungsi harus berakhir dalam 10 detik dan mengembalikan (dengan cara apa pun dan dalam format apa pun) dua nilai: total waktu yang telah berlalu, dan total waktu tidur yang dieksekusi. Kedua nilai waktu harus memiliki ketelitian minimal 0,1 detik.

Ini mirip dengan konsep jam kerja : pekerjaan yang memakan waktu 60 jam dapat diselesaikan hanya dalam 6 jam jika 10 pekerja membagi pekerjaan. Di sini kita dapat memiliki 60 detik waktu tidur misalnya dalam 10 utas paralel, sehingga hanya membutuhkan 6 detik untuk seluruh pekerjaan diselesaikan.

Contoh

Program MyProgram membuat 14 utas, setiap utas tertidur selama 5 detik:

MyProgram[5.016,70.105]

Waktu eksekusi lebih besar dari 5 detik, dan total waktu tidur lebih dari 70 detik karena overhead.

Adm
sumber
2
Saya sudah membaca pertanyaan itu beberapa kali dan saya tidak mengerti. Bisakah Anda menjelaskan sedikit? Mengapa "10 detik" dan penundaan "70 detik"? Bagaimana semua waktu itu terkait?
Luis Mendo
3
Berapa banyak utas yang dapat kita asumsikan akan dieksekusi secara paralel?
miles
3
Apa presisi yang diperlukan untuk waktu dalam output?
edc65
20
Saya bertanya-tanya apakah ini akan menyebabkan semua penulis bahasa golf terlibat dalam dasbor gila untuk menambahkan multi-threading ke kreasi mereka ...
Adám
3
@NoOneIsHere Ah, well, metode tidur yang diimplementasikan dengan benar tidak boleh sibuk inti, sehingga jumlah utas mungkin melebihi jumlah prosesor (virtual).
Adám

Jawaban:

15

Dyalog APL, 65 27 23 21 byte

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

Yaitu:

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

Penjelasan:

  • ⎕DL&¨9/7: spin off 9 utas, masing-masing menunggu selama 7 detik. ⎕DLmengembalikan jumlah aktual waktu yang dihabiskan menunggu, dalam detik, yang akan sama dengan argumennya memberi atau mengambil beberapa milidetik.
  • ⎕TSYNC: tunggu semua utas selesai, dan dapatkan hasilnya untuk setiap utas.
  • (⌈/,+/): mengembalikan waktu eksekusi terlama dari satu utas tunggal (selama eksekusi semua utas lainnya selesai, jadi ini adalah runtime aktual), diikuti oleh jumlah waktu eksekusi semua utas.

Cobalah online!

marinus
sumber
Ini tidak akan berhasil jika dieksekusi pada 23:59:57. Namun, Anda berada di jalur yang benar ... Meskipun Anda sudah terpendek, bisakah Anda bermain golf 40 byte lagi?
Adám
1
@ Adám: tidak, tapi saya bisa bermain golf sejauh 38 byte. Cukup jelas, saya tidak tahu mengapa saya tidak memikirkan hal ini pertama kali.
marinus
Ini dia. Hanya 6 byte lagi sampai Anda mendapatkan tanda centang. Tiga hal yang harus Anda lakukan juga cukup jelas, yaitu masing-masing menghemat 1, 2, dan 3 byte.
Adám
Sangat bagus, Anda menemukan nomor 1 dan nomor 3. Nomor 2 tidak benar-benar bermain golf, sebanyak alternatif implementasi ...
Adám
Nomor 2: Karena Anda tidak memerlukan argumen, cukup buat itu menjadi badan tfn.
Adám
18

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

Ini membutuhkan OS dengan ketepatan waktu lebih dari 1 detik untuk bekerja dengan baik (dengan kata lain, OS modern). 8 thread dibuat yang masing-masing tidur selama 9 detik, menghasilkan runtime realtime ~ 9 detik, dan runtime paralel ~ 72 detik.

Meskipun dokumentasi resmi mengatakan bahwa Threadkonstruktor harus dipanggil dengan argumen kata kunci, saya tetap berhati-hati dan menggunakan argumen posisi. Argumen pertama ( group) harus None, dan argumen kedua adalah fungsi target.

nneonneo menunjukkan dalam komentar bahwa akses atribut (misalnya f.t) lebih pendek dari akses indeks daftar (misalnya t[0]). Sayangnya, dalam banyak kasus, beberapa byte yang didapat dari melakukan ini akan hilang karena harus membuat objek yang memungkinkan atribut yang ditentukan pengguna dibuat saat runtime. Untungnya, fungsi mendukung atribut yang ditentukan pengguna saat runtime, jadi saya mengeksploitasi ini dengan menghemat waktu total dalam tatribut f.

Cobalah online

Terima kasih kepada DenkerAffe untuk -5 byte dengan exectriknya.

Berkat kundor untuk -7 byte dengan menunjukkan bahwa argumen utasnya tidak perlu.

Berkat nneonneo untuk -7 byte dari peningkatan lain-lain.

Mego
sumber
Anda dapat menyimpan dua byte dengan menghapus argumen f(), dan dua argumen terakhir ke Thread(sehingga menghapus 7 karakter) dan menggunakan t.append(m()-n)untuk menghindari menetapkan variabel lokal t(menggunakan 5 karakter lebih banyak dari +=.)
Nick Matteo
Dan Anda dapat menyimpan lima lagi dengan menyimpan jumlah alih-alih daftar waktu: menginisialisasi tdengan t=[0], ganti append t[0]+=m()-n, dan ganti sum(t)dengan t[0].
Nick Matteo
Nama utas dapat dihilangkan.
pppery
@ppperry: tidak jika Anda perlu menggunakan argumen posisi berikutnya (tetapi seperti yang saya sebutkan di komentar sebelumnya, Anda benar-benar dapat menghilangkannya.)
Nick Matteo
Simpan tiga byte dengan menggunakan import threading as H,time as t; simpan dua byte lagi dengan menggunakan z=H.Threaddan map(z.join,r); simpan dua byte lagi dengan menyimpan waktu total sebagai atribut (mis. T.z+=m()-n)
nneonneo
11

Utilitas Bash + GNU, 85

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

Memaksa penggunaan timeexecutable alih-alih shell builtin dengan awalan dengan a \.

Tambahkan ke file j, yang harus kosong atau tidak ada di awal.

Trauma Digital
sumber
Bagaimana dengan skrip forking seperti; if [ $1 -lt 9 ];then { ./a $(( $1 + 1 )) &};sleep 7;fiatau semacamnya? Apakah itu melanggar aturan, atau sesuatu yang saya tidak mengerti tentang spek? [sunting; Saya melewatkan persyaratan untuk keluaran. Ooh, itu membuatnya menarik!]
Dewi Morgan
1
@DewiMorgan Ya, persyaratan output membuatnya sedikit lebih sulit. Apa yang Anda sarankan bisa bermain golf seperti(($1<9))&&$0 $[$1+1]&sleep 7
Digital Trauma
9

Pergi - 189 byte

Terima kasih @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)}

Output (ms): 160,9939ms, 60001 (160ms untuk menunggu 60,001 detik)

rampok
sumber
1
Halo, dan selamat datang di PPCG! Komentar ini,, @Rob In some languages the obvious solution is already (close to) the shortest. Besides, one way to view code-golf challenges is finding the shortest solution in EACH language. Otherwise Jelly will win most of the time... So: go ahead.tidak berarti Anda tidak boleh mencoba jawaban Anda, tetapi tidak apa-apa jika tidak menang. Bisakah Anda menambahkan solusi golf?
NoOneIsHere
Maaf, saya baru saja membaca hasil edit Anda. Untuk bermain golf, Anda mungkin dapat menghapus baris baru dan spasi, atau mengubah totsesuatu seperti q.
NoOneIsHere
@NoOneIsHere, terima kasih untuk itu, saya mengabaikan variabel itu sepenuhnya! Juga menggedor bersama m dan t.
Rob
1
codebeautify.org/javaviewer - klik minify
cat
8

Bash 196 117 114 93 byte

Diperbarui untuk mendukung ketepatan waktu yang lebih baik dengan mengintegrasikan saran dari @manatwork dan @Digital Trauma serta beberapa optimasi ruang lainnya:

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

Perhatikan bahwa ini mengasumsikan jfile tidak ada di awal.

Julie Pelletier
sumber
2
function ss(), b=`date +%s`b=$SECONDS, expr $t + $i$[t+i], `cat j`$(<j)dan umumnya lihat Tip untuk bermain golf di Bash tentang cara menguranginya menjadi ini: pastebin.com/DDqUaDug
manatwork
Untuk mengurangi lebih banyak, lebih baik tulis langsung formula ke file j. Maksud saya alih-alih 5↵5↵5↵…menulis +5+5+5…- lalu muat semuanya langsung ke evaluasi aritmatika dan luangkan loop kedua: pastebin.com/LB0BjDMZ
manatwork
Karena presisi minimum ditentukan nanti, lupakan b=`date +%s`b=$SECONDSsaran.
manatwork
1
Seperti bashhalnya hitung integer, seluruh solusi perlu ditulis ulang untuk menggunakan alat eksternal untuk perhitungan. Biasanya bc: pastebin.com/eYFEVUuz
manatwork
1
@JuliePelletier Oke, saya akan memposting sebagai jawaban saya sendiri. Namun, saya pikir Anda masih dapat menerapkan beberapa teknik bermain golf untuk jawaban Anda tanpa mengubah pendekatan secara signifikan: pastebin.com/ssYzVs1n (93 bytes)
Digital Trauma
8

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

Berjanji untuk menunggu 9 kali selama 7 detik untuk total 63 detik (sebenarnya 63.43 ketika saya mencoba), tetapi hanya benar-benar mengambil 7.05 detik waktu nyata ketika saya mencoba.

Neil
sumber
8

C, 127 byte (berputar CPU)

Solusi ini memutar CPU alih-alih tidur, dan menghitung waktu menggunakan timesfungsi POSIX (yang mengukur waktu CPU yang dikonsumsi oleh proses induk dan pada semua anak yang menunggu).

Ini memotong 7 proses yang berputar selama 9 detik masing-masing, dan mencetak waktu akhir dalam jam C (pada sebagian besar sistem, 100 tick jam = 1 detik).

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

Output sampel:

906,6347

artinya 9,06 detik waktu nyata dan 63,47 detik total waktu CPU.

Untuk hasil terbaik, kompilasi dengan -std=c90 -m32(memaksa kode 32-bit pada mesin 64-bit).

nneonneo
sumber
5

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

Setel $ddengan Get-Date, dan hapus semua riwayat pekerjaan yang ada Get-Job | Remove-Job. Kami kemudian mengulang 1..20|%{...}dan setiap iterasi mengeksekusi Start-Jobmelewati blok skrip {$x=date;sleep 3;((date)-$x).ticks/1e7}untuk pekerjaan (artinya setiap pekerjaan akan mengeksekusi blok skrip itu). Kami menyalurkan output itu ke >$nulluntuk menekan umpan balik (yaitu, nama pekerjaan, status, dll.) Yang dikembalikan.

Blok skrip disetel $xke Get-Date, lalu Start-Sleepuntuk 3detik, lalu mengambil Get-Datebacaan baru , kurangi $x, dapatkan .Ticks, dan 1e7bagi dengan untuk mendapatkan detik (dengan presisi).

Kembali ke utas utama, selama pekerjaan apa pun masih -Status "Running", kami berputar di dalam whilelingkaran kosong . Setelah selesai, kita Get-Jobmenarik objek untuk semua pekerjaan yang ada, menyalurkan Receive-Jobyang akan menarik setara dengan STDOUT (yaitu, apa yang mereka hasilkan), -joinhasilnya bersama-sama +, dan pipa itu ke iex( Invoke-Expressiondan mirip dengan eval). Ini akan menampilkan waktu tidur yang dihasilkan ditambah overhead.

Baris terakhir serupa, yaitu mendapat tanggal baru, mengurangi cap tanggal asli $d, mendapatkan .Ticks, dan membaginya dengan 1e7untuk menghasilkan total waktu eksekusi.


NB

OK, jadi ini sedikit aturan yang membengkok . Rupanya pada eksekusi pertama, PowerShell perlu memuat sekelompok .NET assemblies dari disk untuk berbagai operasi thread karena mereka tidak dimuat dengan profil shell default. Eksekusi berikutnya , karena majelis sudah dalam memori, berfungsi dengan baik. Jika Anda membiarkan jendela shell cukup lama, Anda akan mendapatkan pengumpulan sampah bawaan PowerShell untuk datang dan membongkar semua rakitan, yang menyebabkan eksekusi berikutnya memakan waktu lama karena memuat ulang mereka. Saya tidak yakin dengan cara ini.

Anda dapat melihat ini di waktu eksekusi di bawah berjalan. Saya memulai shell baru, menavigasi ke direktori golf saya, dan mengeksekusi skrip. Run pertama menghebohkan, tetapi yang kedua (dieksekusi segera) bekerja dengan baik. Saya kemudian meninggalkan shell menganggur selama beberapa menit untuk membiarkan pengumpulan sampah datang, dan kemudian menjalankan itu lagi panjang, tetapi berjalan selanjutnya berfungsi dengan baik.

Contoh berjalan

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>
AdmBorkBork
sumber
1
Saya akan mengatakan itu baik-baik saja. :-)
Adám
5

Javascript (ES6), 212 203 145 byte

Kode ini menghasilkan 10 gambar dengan interval waktu masing-masing tepat 6 detik, setelah memuat.

Waktu pelaksanaan berjalan sedikit di atasnya (karena overhead).

Kode ini menimpa semua yang ada di dokumen!

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)

Ini mengasumsikan bahwa Anda menggunakan pengkodean byte tunggal untuk backticks, yang diperlukan agar mesin Javascript tidak tersandung.


Sebagai alternatif, jika Anda tidak ingin menunggu selama 6 detik, inilah solusi 1 byte lebih lama yang selesai dalam waktu kurang dari satu detik:

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)

Perbedaannya adalah bahwa kode ini menunggu 600 ms melintasi 100 gambar. Ini akan memberikan jumlah overhead yang besar.


Versi lama (203 byte):

Kode ini menciptakan 10 iframe dengan interval waktu masing-masing tepat 6 detik, alih-alih membuat 10 gambar.

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)


Versi asli (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)})

Ismael Miguel
sumber
2
+1 Pendekatan yang sangat bagus dan berbeda. Apa yang akan terjadi pada peramban single-threaded?
Adám
2
@ Adám Tidak ada perubahan perilaku. Masih akan ada penundaan sekitar 6 detik. Firefox (peramban single-threaded) kadang-kadang akan menampilkan hal-hal lucu seperti waktu eksekusi 59999. <sesuatu>.
Ismael Miguel
4

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
histokrat
sumber
4

Javascript (ES6), 108 92 byte

Saya membuat jawaban baru karena ini menggunakan pendekatan yang sedikit berbeda.

Ini menghasilkan sejumlah besar setTimeouts, yang hampir semua dieksekusi dengan 4ms di antara mereka.

Setiap interval adalah 610 milidetik, lebih dari total 99 interval.

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

Biasanya berjalan dalam 610ms, dengan total waktu eksekusi sekitar 60,5 detik.

Ini diuji pada Google Chrome versi 51.0.2704.84 m, di windows 8.1 x64.


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

Ismael Miguel
sumber
4

Scratch - 164 bytes (16 blok)

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

Skrip visual

Lihat beraksi di sini .

Menggunakan variabel yang disebut 't' dan sprite disebut 's'. Sprite menciptakan klon dari dirinya sendiri, masing-masing menunggu 8 detik, dan menambahkan variabel clocking seluruh waktu tunggu. Pada akhirnya dikatakan total waktu eksekusi dan total waktu tunggu (misalnya, 65.488 8.302).

Scimonster
sumber
4

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

Versi terformat dengan variabel bernama:

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

output (dalam nanodetik):

[62999772966 7001137032]

Format yang diubah. Terima kasih Adm, saya mungkin telah melewatkan spesifikasi format dalam pertanyaan ketika saya membacanya.

Diubah menjadi nanoTime untuk kemampuan bermain golf.

Terima kasih cliffroot, saya benar-benar lupa tentang notasi ilmiah dan tidak percaya saya tidak melihat apply. Saya pikir saya menggunakannya dalam sesuatu yang saya main golf kemarin tetapi tidak pernah diposting. Anda menyelamatkan saya 2 byte.

Chris F
sumber
Selamat datang di PPCG! Posting pertama yang bagus! Anda mungkin dapat menanyakan OP tentang format output.
R
Tidak perlu terbalik. OP: dengan cara apa pun dan dalam format apa pun .
Adám
Sepertinya Anda dapat menggunakan 7e3bukannya 7000dan menggunakan applybukannyareduce
cliffroot
3

Rust, 257 , 247 byte

Saya menggunakan waktu yang sama dengan jawaban Python Mego.

Sungguh satu-satunya bit yang sedikit pintar menggunakan ii untuk mendapatkan Durasi 0 detik.

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

Cetakan:

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

Tidak Disatukan:

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

Sunting: baik lama untuk loop sedikit lebih pendek

bergerigis
sumber
3

JavaScript (ES6, menggunakan 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)}

UPD: menggantikan cara pekerja dieksekusi dari string dengan yang lebih kompak dan lintas-browser, dalam aspek kebijakan lintas-asal. Tidak akan berfungsi di Safari, jika masih memiliki webkitURLobjek URL, dan di IE.

bodqhrohro
sumber
1
Saya mendapatkan kesalahan saat menjalankan ini:{ "message": "Uncaught SecurityError: Failed to construct 'Worker': Script at 'data:application/javascript,a%3Dnew%20Date()%3BsetTimeout(()%3D%3EpostMessage(new%20Date()-a)%2C5e3)' cannot be accessed from origin 'null'.", "filename": "http://stacksnippets.net/js", "lineno": 13, "colno": 45 }
DJMcMayhem
3

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

Ini adalah turunan dari jawaban Mego, tetapi cukup berbeda karena saya pikir itu harus menjadi jawaban yang terpisah. Ini diuji untuk bekerja pada Windows.

Pada dasarnya, itu memotong 9 utas, yang tidur selama 7 detik sementara orangtua tidur selama 8. Kemudian ia mencetak waktu. Output sampel:

8.00059192923 71.0259046024

Di Windows, time.clockmengukur waktu dinding sejak panggilan pertama.

nneonneo
sumber
Penting untuk dicatat bahwa ini hanya berfungsi pada Windows - time.clock()berperilaku berbeda antara platform Windows dan UNIX / Linux .
Mego
3

Perl 6, 72 71 byte

Mungkin ada cara yang lebih pendek untuk melakukan ini

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

output ini

63.00660729694
7.0064013
Tombol cepat
sumber
2

Mathematica, 109 byte

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

Fungsi anonim. Memerlukan lisensi dengan 7+ sub-kernel untuk dijalankan. Membutuhkan 9 detik waktu nyata dan 63 detik waktu kernel, tidak memperhitungkan overhead. Pastikan untuk hanya menjalankan pernyataan sebelumnya sekali (sehingga tidak mencoba meluncurkan kembali kernel). Pengujian:

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}
LegionMammal978
sumber
2
Serahkan pada Wolfram untuk memberlakukan batasan lisensi pada proses forking anak.
Mario Carneiro
2

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)

Versi terbaru: 106 byte Dipinjam dari @Ismael Miguel karena ia punya ide bagus untuk menurunkan waktu tidur dan meningkatkan interval.

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

Andrew
sumber
2
Alih-alih d+=t()-s;if(!c)alert([t()-i,d]), Anda dapat menulis d+=t()-s;c||alert([t()-i,d]), yang akan menghemat beberapa byte. Juga, jika Anda menghapus fungsi dan menulis ulang itu semua, Anda dapat bersaing dengan solusi lama 92-byte saya: for(c=8,i=(t=Date.now)(d=0);c--;)setTimeout((c,s)=>{d+=t()-s;c||alert([t()-i,d])},8e3,c,t()). Dan ya, yang ini juga panjangnya 92 byte.
Ismael Miguel
2

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

dan ungolfed

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

tolong jangan mencobanya di rumah, karena solusi ini tidak aman untuk thread.

Sunting:

Saya mengambil saran @A Boschman dan @ Adám, dan sekarang program saya membutuhkan waktu kurang dari 10 detik untuk berjalan, dan lebih pendek 15 byte.

pengguna902383
sumber
2
Anda berada di dalam anak dari kelas Thread, tidak bisakah Anda menghilangkan Thread.panggilan metode sleep statis ()? Juga, bukankah program ini akan berakhir dalam 10 detik, mendiskualifikasi?
Pasang kembali Monica
@ABoschman terima kasih atas sarannya, dan sudah diperbaiki sekarang, itu tidak berjalan lebih dari 10 detik lagi
user902383
1
Juga, jangan lupa kami memiliki banyak tips untuk bermain golf di Jawa :)
Katenkyo
1
Ini tampaknya rentan terhadap kondisi lomba baca-modifikasi-tulis. Anda tidak memiliki penguncian atau apapun di sekitar Anda static long t. Saya hanya menyebutkan ini karena spec mengatakan "Kedua nilai waktu harus memiliki ketelitian minimal 0,1 detik."
Poke
1
Anda dapat menghapus long sebelum sdan menambahkan ,ske static long t,i,s;untuk menyimpan beberapa byte.
Kevin Cruijssen
2

C (dengan 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);}
bodqhrohro
sumber
2

C90 (OpenMP), 131 Bytes (+ 17 untuk variabel env) = 148 Bytes

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

Contoh Output:

7091,9.000014

Catatan:

7091 dalam siklus (100 / detik), sehingga program berjalan selama 70 detik

Bisa jadi jauh lebih pendek jika saya menemukan cara untuk mendapatkan timer untuk bekerja selain omp_get_wtime () karena saya bisa menghapus pernyataan include juga.

Jalankan dengan OMP_NUM_THREADS = 9

dj0wns
sumber
Anda dapat mengatur env var, tetapi Anda harus menghitung byte untuk melakukannya, kecuali jika pengaturan yang Anda pilih adalah standar umum.
Adám
@ Adam Terima kasih, itu yang saya pikir, menghemat 6 atau 7 byte
dj0wns
2

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

Ini hanya memunculkan thread yang tidur dan kemudian secara atom meningkatkan waktu yang diperlukan, dengan loop luar yang berputar menunggu total waktu menjadi lebih dari 60000 kutu (yaitu 60 detik pada sbcl). Penghitung disimpan dalam daftar karena keterbatasan pada jenis tempat yang dapat dimodifikasi oleh atom-incf. Ini mungkin kehabisan ruang sebelum berhenti pada mesin yang lebih cepat.

Tidak Disatukan:

(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)))))
Jason
sumber
2

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

Garpu 7 proses anak, masing-masing menunggu 9 detik.

Output sampel:

perl wait-one-minute.pl
9.00925707817078-63.001741
primo
sumber
1

Groovy, 158 143 karakter

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

Contoh dijalankan:

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

Elixir, 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)

Contoh dijalankan:

$ elixir thing.exs
64012846
4007547

Outputnya adalah total waktu yang ditunggu diikuti oleh waktu program berjalan, dalam mikrodetik.

Program ini menghasilkan 14 Taskdetik, dan menunggu masing-masing dengan memetakannya, dan kemudian menemukan jumlah waktu yang telah berlalu. Ini menggunakan Erlang timeruntuk mengukur waktu.

Permen Gumdrop
sumber
Selamat datang di komunitas !!
Erik the Outgolfer
1

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

!mengukur waktu yang diambil oleh tindakan a(argumen kedua) dan berlaku b(argumen pertama) untuk hasilnya.

w adalah fungsi tidur.

maindiukur sendiri, dan hasilnya dicetak ( print!...).

#adalah replicateM, mengulangi tindakan yang diberikan sebanyak N kali (dan kembali tkarena bermain golf).

Di dalam bagian yang diukur, 9 utas ( replicate 9 $ forkIO ...) tidur selama 5^10milidetik (9,765625 detik) dan posting hasilnya ( writeChan) ke pipa yang dibuat oleh utas utama ( newChan), yang merangkum 9 hasil dan mencetak total ( getChanContents >>= print . sum . take 9).

Keluaran:

87.938546708s
9.772032144s
Koterpillar
sumber
1
@ Adám 6 ^ 9> 10 ^ 7 (10 detik).
Koterpillar
1

Python 2, 132 byte

Menggunakan kumpulan proses untuk menghasilkan 9 proses dan biarkan masing-masing tidur selama 7 detik.

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

Mencetak total akumulasi sleeptime pertama, kemudian runtime yang sebenarnya:

$ python test.py
63.0631158352 7.04391384125
moooeeeep
sumber
1

Ruby (dengan parallelpermata), 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

Sunting: Menambahkan referensi "Time.now" dari jawaban Ruby oleh histocrat.

Gosha U.
sumber
1

Matlab, 75 byte

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

Penjelasan cepat: parformembuat loop paralel, didistribusikan di seluruh kumpulan pekerja. ticdan tocmengukur waktu yang telah berlalu (dan menurut saya salah satu fungsi terbaik yang disebutkan di MATLAB). Baris terakhir (array dengan total waktu tidur dan waktu sebenarnya berlalu) dikeluarkan karena tidak diakhiri dengan tanda titik koma.

Namun perlu dicatat bahwa ini menciptakan 9 proses MATLAB lengkap. Kemungkinannya adalah bahwa program khusus ini tidak akan selesai dalam waktu 10 detik yang diberikan pada mesin Anda. Namun, saya pikir dengan instalasi MATLAB yang tidak memiliki kotak alat kecuali kotak alat Komputasi Paralel yang diinstal - diinstal pada sistem high-end dengan SSD - mungkin hanya dapat selesai dalam 10 detik. Jika diperlukan, Anda dapat mengubah parameter agar proses tidur lebih sedikit.

Sanchises
sumber
Kesalahan tentang bkemungkinan hanya karena Anda sudah memiliki sesuatu di ruang kerja Anda. Saya tidak punya masalah pada 2015b menggunakanparfor q=b
Suever
@Suever Oh, hei, saya punya skrip bernama bm di folder MATLAB saya.
Sanchises