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.
Jawaban:
Dyalog APL,
65272321 byteYaitu:
Penjelasan:
⎕DL&¨9/7
: spin off 9 utas, masing-masing menunggu selama 7 detik.⎕DL
mengembalikan 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!
sumber
Python 2, 172 byte
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
Thread
konstruktor harus dipanggil dengan argumen kata kunci, saya tetap berhati-hati dan menggunakan argumen posisi. Argumen pertama (group
) harusNone
, dan argumen kedua adalah fungsi target.nneonneo menunjukkan dalam komentar bahwa akses atribut (misalnya
f.t
) lebih pendek dari akses indeks daftar (misalnyat[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 dalamt
atributf
.Cobalah online
Terima kasih kepada DenkerAffe untuk -5 byte dengan
exec
triknya.Berkat kundor untuk -7 byte dengan menunjukkan bahwa argumen utasnya tidak perlu.
Berkat nneonneo untuk -7 byte dari peningkatan lain-lain.
sumber
f()
, dan dua argumen terakhir keThread
(sehingga menghapus 7 karakter) dan menggunakant.append(m()-n)
untuk menghindari menetapkan variabel lokalt
(menggunakan 5 karakter lebih banyak dari+=
.)t
dengant=[0]
, ganti appendt[0]+=m()-n
, dan gantisum(t)
dengant[0]
.import threading as H,time as t
; simpan dua byte lagi dengan menggunakanz=H.Thread
danmap(z.join,r)
; simpan dua byte lagi dengan menyimpan waktu total sebagai atribut (mis.T.z+=m()-n
)Utilitas Bash + GNU, 85
Memaksa penggunaan
time
executable alih-alih shell builtin dengan awalan dengan a\
.Tambahkan ke file
j
, yang harus kosong atau tidak ada di awal.sumber
if [ $1 -lt 9 ];then { ./a $(( $1 + 1 )) &};sleep 7;fi
atau semacamnya? Apakah itu melanggar aturan, atau sesuatu yang saya tidak mengerti tentang spek? [sunting; Saya melewatkan persyaratan untuk keluaran. Ooh, itu membuatnya menarik!](($1<9))&&$0 $[$1+1]&sleep 7
Pergi - 189 byte
Terima kasih @cat!
Output (ms): 160,9939ms, 60001 (160ms untuk menunggu 60,001 detik)
sumber
@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?tot
sesuatu sepertiq
.Bash
19611711493 byteDiperbarui untuk mendukung ketepatan waktu yang lebih baik dengan mengintegrasikan saran dari @manatwork dan @Digital Trauma serta beberapa optimasi ruang lainnya:
Perhatikan bahwa ini mengasumsikan
j
file tidak ada di awal.sumber
function s
→s()
,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/DDqUaDug5↵5↵5↵…
menulis+5+5+5…
- lalu muat semuanya langsung ke evaluasi aritmatika dan luangkan loop kedua: pastebin.com/LB0BjDMZb=`date +%s`
→b=$SECONDS
saran.bash
halnya hitung integer, seluruh solusi perlu ditulis ulang untuk menggunakan alat eksternal untuk perhitungan. Biasanyabc
: pastebin.com/eYFEVUuzJavaScript (ES6), 148 byte
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.
sumber
C, 127 byte (berputar CPU)
Solusi ini memutar CPU alih-alih tidur, dan menghitung waktu menggunakan
times
fungsi 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).
Output sampel:
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).sumber
PowerShell v4, 144 byte
Setel
$d
denganGet-Date
, dan hapus semua riwayat pekerjaan yang adaGet-Job | Remove-Job
. Kami kemudian mengulang1..20|%{...}
dan setiap iterasi mengeksekusiStart-Job
melewati 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>$null
untuk menekan umpan balik (yaitu, nama pekerjaan, status, dll.) Yang dikembalikan.Blok skrip disetel
$x
keGet-Date
, laluStart-Sleep
untuk3
detik, lalu mengambilGet-Date
bacaan baru , kurangi$x
, dapatkan.Ticks
, dan1e7
bagi dengan untuk mendapatkan detik (dengan presisi).Kembali ke utas utama, selama pekerjaan apa pun masih
-S
tatus"Running"
, kami berputar di dalamwhile
lingkaran kosong . Setelah selesai, kitaGet-Job
menarik objek untuk semua pekerjaan yang ada, menyalurkanReceive-Job
yang akan menarik setara dengan STDOUT (yaitu, apa yang mereka hasilkan),-join
hasilnya bersama-sama+
, dan pipa itu keiex
(Invoke-Expression
dan mirip denganeval
). 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 dengan1e7
untuk 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
sumber
Javascript (ES6),
212203145 byteKode 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!
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:
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.
Versi asli (212 byte):
sumber
Ruby, 92
sumber
Javascript (ES6),
10892 byteSaya membuat jawaban baru karena ini menggunakan pendekatan yang sedikit berbeda.
Ini menghasilkan sejumlah besar
setTimeout
s, yang hampir semua dieksekusi dengan 4ms di antara mereka.Setiap interval adalah 610 milidetik, lebih dari total 99 interval.
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):
sumber
Scratch - 164 bytes (16 blok)
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
).sumber
Clojure,
135120111109 byteVersi terformat dengan variabel bernama:
output (dalam nanodetik):
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.sumber
7e3
bukannya7000
dan menggunakanapply
bukannyareduce
Rust,
257, 247 byteSaya menggunakan waktu yang sama dengan jawaban Python Mego.
Sungguh satu-satunya bit yang sedikit pintar menggunakan ii untuk mendapatkan Durasi 0 detik.
Cetakan:
Tidak Disatukan:
Sunting: baik lama untuk loop sedikit lebih pendek
sumber
JavaScript (ES6, menggunakan WebWorkers),
233215 byteUPD: 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
webkitURL
objekURL
, dan di IE.sumber
{ "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 }
Python 2, 130 byte
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:
Di Windows,
time.clock
mengukur waktu dinding sejak panggilan pertama.sumber
time.clock()
berperilaku berbeda antara platform Windows dan UNIX / Linux .Perl 6,
7271 byteMungkin ada cara yang lebih pendek untuk melakukan ini
output ini
sumber
Mathematica, 109 byte
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:
sumber
Javascript (ES6), 105 byte
Versi terbaru: 106 byte Dipinjam dari @Ismael Miguel karena ia punya ide bagus untuk menurunkan waktu tidur dan meningkatkan interval.
Javascript Ungolfed, 167 byte
sumber
d+=t()-s;if(!c)alert([t()-i,d])
, Anda dapat menulisd+=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.Java,
358 343 337 316313 bytedan ungolfed
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.
sumber
Thread.
panggilan metode sleep statis ()? Juga, bukankah program ini akan berakhir dalam 10 detik, mendiskualifikasi?static long t
. Saya hanya menyebutkan ini karena spec mengatakan "Kedua nilai waktu harus memiliki ketelitian minimal 0,1 detik."long
sebelums
dan menambahkan,s
kestatic long t,i,s;
untuk menyimpan beberapa byte.C (dengan pthreads),
339336335 bytesumber
C90 (OpenMP), 131 Bytes (+ 17 untuk variabel env) = 148 Bytes
Contoh Output:
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
sumber
Common Lisp (SBCL) 166 byte:
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:
sumber
Perl, 101 byte
Garpu 7 proses anak, masing-masing menunggu 9 detik.
Output sampel:
sumber
Groovy,
158143 karakterContoh dijalankan:
sumber
Elixir, 168 byte
Contoh dijalankan:
Outputnya adalah total waktu yang ditunggu diikuti oleh waktu program berjalan, dalam mikrodetik.
Program ini menghasilkan 14
Task
detik, dan menunggu masing-masing dengan memetakannya, dan kemudian menemukan jumlah waktu yang telah berlalu. Ini menggunakan Erlangtimer
untuk mengukur waktu.sumber
Haskell,
278271262246 byte!
mengukur waktu yang diambil oleh tindakana
(argumen kedua) dan berlakub
(argumen pertama) untuk hasilnya.w
adalah fungsi tidur.main
diukur sendiri, dan hasilnya dicetak (print!...
).#
adalahreplicateM
, mengulangi tindakan yang diberikan sebanyak N kali (dan kembalit
karena bermain golf).Di dalam bagian yang diukur, 9 utas (
replicate 9 $ forkIO ...
) tidur selama5^10
milidetik (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:
sumber
Python 2, 132 byte
Menggunakan kumpulan proses untuk menghasilkan 9 proses dan biarkan masing-masing tidur selama 7 detik.
Mencetak total akumulasi sleeptime pertama, kemudian runtime yang sebenarnya:
sumber
Ruby (dengan
parallel
permata),123116 byteSunting: Menambahkan referensi "Time.now" dari jawaban Ruby oleh histocrat.
sumber
Matlab, 75 byte
Penjelasan cepat:
parfor
membuat loop paralel, didistribusikan di seluruh kumpulan pekerja.tic
dantoc
mengukur 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.
sumber
b
kemungkinan hanya karena Anda sudah memiliki sesuatu di ruang kerja Anda. Saya tidak punya masalah pada 2015b menggunakanparfor q=b