एक मिनट रुकें - दस सेकंड से भी कम समय में


69

कार्य

किसी भी प्रकार के समांतरिकरण का उपयोग करते हुए, कम से कम एक मिनट (लेकिन एक मिनट और डेढ़ से कम) की कुल नींद के समय के लिए, कई अवधियों की प्रतीक्षा करें।

कार्यक्रम / फ़ंक्शन को 10 सेकंड के भीतर समाप्त करना चाहिए और वापस लौटना चाहिए (किसी भी माध्यम से और किसी भी प्रारूप में) दो मान: कुल बीता हुआ समय और कुल निष्पादित नींद का समय। दोनों समय मानों में कम से कम 0.1 सेकंड की सटीकता होनी चाहिए।

यह मानव-घंटे की अवधारणा के समान है : एक नौकरी जिसमें 60 घंटे लगते हैं, केवल 6 घंटों में पूरा किया जा सकता है यदि 10 कर्मचारी नौकरी से अलग हो रहे हैं। यहां हमारे पास 10 समानांतर धागों में 60 सेकंड की नींद का समय हो सकता है, इस प्रकार पूरी नौकरी के लिए केवल 6 सेकंड की आवश्यकता होती है।

उदाहरण

कार्यक्रम MyProgram 14 धागे बनाता है, प्रत्येक थ्रेड 5 सेकंड के लिए सोता है:

MyProgram[5.016,70.105]

निष्पादन का समय 5 सेकंड से अधिक है, और ओवरहेड के कारण कुल नींद का समय 70 सेकंड से अधिक है।


2
मैंने कई बार सवाल पढ़ा है और मुझे नहीं मिला। क्या आप थोड़ा स्पष्ट कर सकते हैं? क्यों "10 सेकंड" और "70 सेकंड" की देरी? वे सभी समय संबंधित कैसे हैं?
लुइस मेन्डो

3
कितने धागे हम मान सकते हैं कि समानांतर में निष्पादित किया जाएगा?
मील

3
आउटपुट में समय के लिए क्या सटीकता की आवश्यकता है?
edc65

20
मुझे आश्चर्य है कि अगर यह सभी गोल्फ भाषा के लेखकों को अपनी रचनाओं में मल्टी-थ्रेडिंग को जोड़ने के लिए एक पागल डैश में संलग्न करने का कारण बनेगा ...
Adám

3
@NoOneIsHere आह, ठीक है, एक अच्छी तरह से लागू नींद विधि एक कोर को व्यस्त नहीं करना चाहिए, इसलिए थ्रेड्स की संख्या (आभासी) प्रोसेसर की संख्या से अधिक हो सकती है।
आदम

जवाबों:


15

डायलाग एपीएल, 65 27 23 21 बाइट्स

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

अर्थात:

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

स्पष्टीकरण:

  • ⎕DL&¨9/7: 9 थ्रेड्स को स्पिन करें, जिनमें से प्रत्येक 7 सेकंड के लिए प्रतीक्षा करता है। ⎕DLप्रतीक्षा में बिताए गए वास्तविक समय को सेकंडों में लौटाता है, जो उसके तर्क को कुछ मिलीसेकंड देने या लेने के समान होगा।
  • ⎕TSYNC: सभी थ्रेड्स के पूरा होने तक प्रतीक्षा करें, और प्रत्येक थ्रेड के लिए परिणाम प्राप्त करें।
  • (⌈/,+/): एक एकल थ्रेड का सबसे लंबा निष्पादन समय लौटाएं (जिसके निष्पादन के दौरान अन्य सभी धागे समाप्त हो गए, इसलिए यह वास्तविक रनटाइम है), इसके बाद सभी थ्रेड्स के निष्पादन समय का योग।

इसे ऑनलाइन आज़माएं!


23:59:57 पर निष्पादित होने पर यह काम नहीं करेगा। हालाँकि, आप सही रास्ते पर हैं ... जबकि आप पहले से ही सबसे छोटे हैं, क्या आप एक और 40 बाइट्स से दूर जा सकते हैं?
अदम

1
@ Adám: नहीं, लेकिन मैं 38 बाइट दूर कर सकता हूं। यह काफी स्पष्ट है, मुझे नहीं पता कि मैंने इसके बारे में पहली बार क्यों नहीं सोचा।
मारिनस

तुम वहाँ जाओ। केवल एक और 6 बाइट्स जब तक आपको एक चेकमार्क नहीं मिलता। आपको जो तीन चीजें करनी हैं, वे बहुत स्पष्ट हैं, क्रमशः 1, 2, और 3 बाइट्स की बचत।
अदम

बहुत अच्छा, आपको नंबर 1 और नंबर 3 मिला। नंबर 2 वास्तव में गोल्फिंग नहीं है, जितना कि एक कार्यान्वयन विकल्प ...
एडम

नंबर 2: जैसा कि आपको तर्कों की आवश्यकता नहीं है, बस इसे एक tfn निकाय में बनाएं।
आदम

18

पायथन 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 सेकंड से अधिक समय (दूसरे शब्दों में, किसी भी आधुनिक ओएस) के साथ एक ओएस की आवश्यकता होती है। 8 धागे बनाए जाते हैं जो प्रत्येक 9 सेकंड के लिए सोते हैं, जिसके परिणामस्वरूप ~ 9 सेकंड का रीयलटाइम रनटाइम और ~ 72 सेकंड का समानांतर रनटाइम होता है।

हालांकि आधिकारिक दस्तावेज में कहा गया है कि Threadकंस्ट्रक्टर को कीवर्ड तर्कों के साथ बुलाया जाना चाहिए, मैं हवा को सावधानी से फेंकता हूं और वैसे भी स्थिति संबंधी तर्कों का उपयोग करता हूं। पहला तर्क ( group) होना चाहिए None, और दूसरा तर्क लक्ष्य फ़ंक्शन है।

nneonneo ने टिप्पणियों में बताया कि एक्सेस (जैसे f.t) सूची इंडेक्स एक्सेस (जैसे t[0]) से कम है । दुर्भाग्य से, ज्यादातर मामलों में, ऐसा करने से प्राप्त कुछ बाइट्स को एक ऐसी वस्तु बनाने की आवश्यकता होती है जो उपयोगकर्ता-परिभाषित विशेषताओं को रनटाइम पर बनाने की अनुमति देती है। सौभाग्य से, फ़ंक्शन रनटाइम पर उपयोगकर्ता-परिभाषित विशेषताओं का समर्थन करते हैं, इसलिए मैं इसका उपयोग tविशेषता के कुल समय को बचाकर करता हूं f

इसे ऑनलाइन आज़माएं

execचाल के साथ -5 बाइट के लिए DenkerAffe के लिए धन्यवाद ।

थ्रेड तर्क अनावश्यक है, यह इंगित करके -7 बाइट्स के लिए कुंदर के लिए धन्यवाद।

विविध सुधारों से -7 बाइट्स के लिए nneonneo के लिए धन्यवाद।


आप दो बाइट्स को तर्क को हटाकर f(), और अंतिम दो तर्कों Thread(इस प्रकार 7 वर्णों को हटाकर) और t.append(m()-n)स्थानीय चर असाइन करने से बचने के लिए tउपयोग कर सकते हैं (से अधिक 5 वर्णों का उपयोग करते हुए +=)
निक मैटेओ

और आप समय की सूची के बजाय योग को रखकर पांच और बचा सकते हैं: के tसाथ आरंभ करें t=[0], एपेंड को t[0]+=m()-nबदलें, और sum(t)द्वारा प्रतिस्थापित करें t[0]
निक मैट्टे

थ्रेड नाम छोड़ा जा सकता है।
pppery

@ppperry: यदि आपको बाद की स्थिति के तर्कों का उपयोग करने की आवश्यकता नहीं है (लेकिन जैसा कि मैंने पिछली टिप्पणियों में उल्लेख किया है, तो आप उन लोगों को समझा सकते हैं।)
निक मैटेओ

उपयोग करके तीन बाइट्स सहेजें import threading as H,time as t; एक और दो बाइट्स का उपयोग करके z=H.Threadऔर map(z.join,r); एक विशेषता के रूप में कुल समय को T.z+=m()-n
नष्ट

11

बाश + जीएनयू उपयोगिताओं, 85

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

timeएक के साथ उपसर्ग द्वारा शेल बिलिन के बजाय निष्पादन योग्य के उपयोग को मजबूर करता है \

एक फ़ाइल पर लागू होता है j, जो शुरू में खाली या गैर-मौजूद होना चाहिए।


कांटे की स्क्रिप्ट के बारे में क्या; if [ $1 -lt 9 ];then { ./a $(( $1 + 1 )) &};sleep 7;fiया सोमसुख? क्या वह नियमों के विरुद्ध होगा, या मैं किसी चीज़ के बारे में नहीं समझ रहा हूँ? [संपादित करें; मैंने आउटपुट की आवश्यकता को याद किया। ऊह, जो इसे दिलचस्प बनाता है!]
डेवी मोर्गन

1
@DewiMorgan हाँ, आउटपुट आवश्यकता इसे थोड़ा कठिन बना देती है। आप जो सुझाव देते हैं, वह कुछ इस तरह का हो सकता है(($1<9))&&$0 $[$1+1]&sleep 7
डिजिटल ट्रामा

9

गो - 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.9939ms, 60001 (160ms 60.001 सेकंड इंतजार करने के लिए)


1
नमस्कार, और PPCG में आपका स्वागत है! इस टिप्पणी का यह @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.मतलब नहीं है कि आपको अपने उत्तर को गोल करने की कोशिश नहीं करनी चाहिए , लेकिन यह ठीक है कि अगर यह नहीं जीतता है। क्या आप कृपया एक गोल्फ समाधान जोड़ सकते हैं?
NoOneIsHere

मुझे क्षमा करें, मैंने अभी आपका संपादन पढ़ा है। गोल्फ के लिए, आप शायद newlines और रिक्त स्थान को हटा सकते हैं, या totऐसा कुछ बदल सकते हैं q
NoOneIsHere

@NoOneIsHere, इसके लिए धन्यवाद, मैंने उस चर को पूरी तरह से अनदेखा कर दिया! इसके अलावा एम और टी एक साथ धमाकेदार।
रोब

1
codebeautify.org/javaviewer - कम करें क्लिक करें
बिल्ली


8

बैश 196 117 114 93 बाइट्स

@Manatwork और @ डिजीटल ट्रॉमा के सुझावों के साथ-साथ कुछ अन्य स्पेस ऑप्टिमाइज़ेशन से बेहतर समय सटीकता का समर्थन करने के लिए अपडेट किया गया है:

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

ध्यान दें कि यह मानता है कि jफ़ाइल शुरुआत में अनुपस्थित है।


2
function ss(), b=`date +%s`b=$SECONDS, expr $t + $i$[t+i], `cat j`$(<j)और आम तौर पर बैश में गोल्फिंग के लिए टिप्स देखें कि इसे कैसे कम किया जाए: pastebin.com/DDqUaDug
manatwork

इसे और कम करने के लिए, बेहतर फ़ाइल जे के लिए सीधे एक सूत्र लिखें। मेरा मतलब है कि 5↵5↵5↵…लिखने के बजाय +5+5+5…- फिर इसे सीधे अंकगणित मूल्यांकन में लोड करें और दूसरे लूप को अलग करें: pastebin.com/LB0BjDMZ
manatwork

जैसा कि न्यूनतम परिशुद्धता बाद में निर्दिष्ट किया गया था, b=`date +%s`b=$SECONDSसुझाव को भूल जाओ ।
मैनटवर्क

1
जैसा bashकि केवल पूर्णांक अंकगणित है, गणना के लिए बाहरी उपकरण का उपयोग करने के लिए संपूर्ण समाधान को फिर से लिखना होगा। आमतौर पर bc: pastebin.com/eYFEVUuz
मैनटवर्क

1
@JuliePelletier ठीक है, मैं इसे अपने जवाब के रूप में पोस्ट करूँगा। फिर भी, मुझे लगता है कि आप अभी भी गोल्फिंग तकनीकों में से कुछ को अपने जवाब में लागू कर सकते हैं बिना दृष्टिकोण में बदलाव किए: पास्टेबिन.com / ssYzVs1n (93 बाइट्स)
डिजिटल ट्रॉमा

8

जावास्क्रिप्ट (ईएस 6), 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]));

कुल 63 सेकंड के लिए 7 सेकंड के लिए 9 बार प्रतीक्षा करने का वादा करता है (वास्तव में 63.43 जब मैं कोशिश करता हूं), लेकिन वास्तव में केवल 7.05 सेकंड वास्तविक समय लेता हूं जब मैं कोशिश करता हूं।


8

C, 127 बाइट्स (Spins CPU)

यह समाधान सोने के बजाय सीपीयू को घूमता है, और timesपोसिक्स फ़ंक्शन का उपयोग करके समय की गणना करता है (जो कि मूल प्रक्रिया द्वारा और सभी प्रतीक्षा किए गए बच्चों के लिए सीपीयू समय की खपत करता है)।

यह 7 प्रक्रियाओं को बंद करता है जो 9 सेकंड के लिए स्पिन करता है, और सी घड़ियों में अंतिम बार प्रिंट करता है (अधिकांश सिस्टम पर, 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 सेकंड कुल सीपीयू समय।

सर्वोत्तम परिणामों के लिए, -std=c90 -m32(64-बिट मशीन पर 32-बिट कोड के साथ ) संकलित करें ।


5

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-Sleep3Get-Date$x.Ticks1e7

मुख्य धागे में वापस, जब तक कि कोई भी काम अभी भी -Sटेटस है "Running", हम एक खाली whileलूप के अंदर स्पिन करते हैं । एक बार ऐसा करने के बाद, हम Get-Jobसभी मौजूदा नौकरियों के लिए वस्तुओं को खींचते हैं, उन पर पाइप Receive-Jobलगाते हैं जो एसटीडीयूएसटी के बराबर खींचेंगे (यानी, वे क्या आउटपुट करते हैं), -joinपरिणाम एक साथ +, और इसे iex( Invoke-Expressionऔर इसी तरह eval) पाइप करें । यह परिणामी नींद के समय के साथ-साथ ओवरहेड उत्पादन करेगा।

अंतिम पंक्ति समान है, जिसमें यह एक नई तिथि प्राप्त करता है, मूल तिथि स्टाम्प को घटाता $dहै .Ticks, 1e7कुल निष्पादन समय को आउटपुट करने के लिए और प्राप्त करता है ।


एनबी

ठीक है, इसलिए यह नियमों का एक छोटा सा मोड़ है। जाहिरा तौर पर पहले निष्पादन पर, PowerShell को विभिन्न थ्रेड ऑपरेशन के लिए डिस्क से .NET असेंबली का एक गुच्छा लोड करने की आवश्यकता होती है क्योंकि वे डिफ़ॉल्ट शेल प्रोफाइल के साथ लोड नहीं होते हैं। बाद के निष्पादन, क्योंकि विधानसभाएं पहले से ही स्मृति में हैं, ठीक काम करती हैं। यदि आप शेल विंडो बेकार छोड़ देते हैं, तो आपको 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>

1
मैं कहूंगा कि यह ठीक है। :-)
एडम

5

जावास्क्रिप्ट (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)

यह मानता है कि आप backticks के लिए एकल-बाइट एन्कोडिंग का उपयोग करते हैं, जिसे जावास्क्रिप्ट इंजन के लिए यात्रा की आवश्यकता नहीं होती है।


वैकल्पिक रूप से, यदि आप 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 छवियों को बनाने के बजाय प्रत्येक के ठीक 6 सेकंड के समय अंतराल के साथ 10 iframes बनाता है।

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


2
+1 बहुत अच्छा और अलग तरीका। एकल-थ्रेडेड ब्राउज़र में क्या होगा?
अड्म

2
@ व्यवहार में कोई बदलाव नहीं। अभी भी लगभग 6 सेकंड की देरी होगी। फ़ायरफ़ॉक्स (एक एकल-थ्रेडेड ब्राउज़र) कभी-कभी 59999 के निष्पादन समय जैसे मज़ेदार सामान का उत्पादन करेगा। <कुछ>।
इस्माइल मिगुएल

4

रूबी, 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

4

जावास्क्रिप्ट (ES6), 108 92 बाइट्स

मैं एक नया जवाब दे रहा हूँ क्योंकि यह थोड़ा अलग aproach का उपयोग करता है।

यह बड़े पैमाने पर राशि उत्पन्न करता है setTimeout, जो लगभग सभी के बीच 4ms के साथ निष्पादित होते हैं।

प्रत्येक अंतराल 610 मिलीसेकंड का है, जो कुल 99 अंतराल से अधिक है।

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

यह आम तौर पर लगभग 60.5 सेकंड के कुल निष्पादन समय के लिए 610ms के भीतर चलता है।

यह Google क्रोम संस्करण 51.0.2704.84 मीटर, विंडोज़ 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))


4

स्क्रैच - 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) कहता है ।


4

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]

परिवर्तित स्वरूप। धन्यवाद एडम, मैं उस प्रारूप विनिर्देश को याद कर सकता हूं जब मैंने इसे पढ़ा था।

गोल्फिंग क्षमताओं के लिए नैनो टाइम में बदला।

धन्यवाद cliffroot, मैं पूरी तरह से वैज्ञानिक संकेतन के बारे में भूल गया और विश्वास नहीं कर सकता कि मैंने नहीं देखा apply। मुझे लगता है कि मैंने उस चीज का इस्तेमाल किया था जिसे मैं कल गोल्फ कर रहा था लेकिन कभी पोस्ट नहीं किया। आपने मुझे 2 बाइट्स से बचाया।


PPCG में आपका स्वागत है! अच्छी पहली पोस्ट! आप आउटपुट प्रारूप के बारे में ओपी से पूछ सकते हैं।
R

उलटने की जरूरत नहीं। ओपी: किसी भी तरह से और किसी भी प्रारूप में
एडम

लगता है कि आप उपयोग कर सकते 7e3के बजाय 7000और प्रयोग applyके बजायreduce
cliffroot

3

जंग, 257 , 247 बाइट्स

मैं उसी समय का उपयोग करता हूं जैसे कि मेगो के पायथन उत्तर।

वास्तव में केवल थोड़ा चतुर बिट 0 सेकंड की अवधि प्राप्त करने के लिए ii का उपयोग कर रहा है।

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 }

Ungolfed:

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

संपादित करें: लूप के लिए अच्छा पुराना थोड़ा छोटा है


3

जावास्क्रिप्ट (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: क्रॉस-ऑरिजनल पॉलिसियों के पहलू में एक कार्यकर्ता को एक अधिक कॉम्पैक्ट और क्रॉस-ब्राउज़र वाले स्ट्रिंग से निष्पादित किया जाता है। सफ़ारी में काम नहीं करेगा, अगर इसके पास अभी भी webkitURLवस्तु है URL, और IE में।


1
: जब मैं इस चलाने मैं एक त्रुटि हो रही है{ "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

पायथन 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

यह मीगो के उत्तर की व्युत्पत्ति है, लेकिन यह पर्याप्त रूप से अलग है कि मुझे लगा कि यह एक अलग उत्तर होना चाहिए। यह विंडोज पर काम करने के लिए परीक्षण किया गया है।

मूल रूप से, यह 9 धागे बंद कर देता है, जो 7 सेकंड के लिए सोते हैं जबकि माता-पिता 8 के लिए सोते हैं। फिर यह समय को प्रिंट करता है। नमूना उत्पादन:

8.00059192923 71.0259046024

विंडोज पर, time.clockपहली कॉल के बाद से दीवार के समय को मापता है।


यह ध्यान रखना महत्वपूर्ण है कि यह केवल विंडोज पर काम करता है - time.clock()विंडोज और यूनिक्स / लिनक्स प्लेटफार्मों के बीच अलग-अलग व्यवहार करता है
मेगो

3

पर्ल 6, 72 71 बाइट्स

ऐसा करने का एक छोटा तरीका हो सकता है

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

यह आउटपुट है

63.00660729694
7.0064013

2

गणितज्ञ, 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}

2
एक बच्चे की प्रक्रिया के लिए लाइसेंस प्रतिबंध लगाने के लिए इसे वुल्फराम पर छोड़ दें।
मारियो कार्नेरो

2

जावास्क्रिप्ट (ईएस 6), 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 बाइट्स @ इस्माईल मिगुएल से उधार लिया गया क्योंकि उसके पास सोने के समय को कम करने और अंतराल बढ़ाने के लिए बहुत अच्छा विचार था।

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

जावास्क्रिप्ट 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)


2
इसके बजाय d+=t()-s;if(!c)alert([t()-i,d]), आप लिख सकते हैं d+=t()-s;c||alert([t()-i,d]), जो कुछ बाइट्स को बचाएगा। इसके अलावा, यदि आप फ़ंक्शन को हटाते हैं और इसे फिर से लिखते हैं, तो आप मेरे 92-बाइट लंबे समाधान के साथ प्रतिस्पर्धा कर सकते हैं for(c=8,i=(t=Date.now)(d=0);c--;)setTimeout((c,s)=>{d+=t()-s;c||alert([t()-i,d])},8e3,c,t()):। और हाँ, यह भी 92 बाइट्स लंबा है।
इस्माइल मिगुएल

2

जावा, 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's और @ Adám के सुझावों को लिया, और अब मेरे कार्यक्रम को चलाने के लिए 10 सेकंड से कम की आवश्यकता है, और यह 15 बाइट्स से छोटा है।


2
आप थ्रेड क्लास के एक बच्चे के अंदर हैं, क्या आप Thread.स्टैटिक स्लीप () मेथड कॉल्स से नहीं चूक सकते ? इसके अलावा, क्या यह कार्यक्रम 10 सेकंड में इसे अयोग्य घोषित नहीं कर देगा?
एक बॉशमैन

सुझाव के लिए @ABoschman धन्यवाद, और अब तक तय है, यह अब 10 सेकंड से अधिक नहीं चलता है
user902383

1
यह भी मत भूलिए कि हमारे पास जावा में गोल्फिंग के लिए शानदार टिप्स हैं। :)
काटनेंको

1
यह दौड़ की स्थितियों को पढ़ने-संशोधित करने-लिखने के लिए अतिसंवेदनशील लगता है। आपके पास किसी भी प्रकार का ताला या आपके आसपास कुछ भी नहीं है static long t। मैं केवल इसका उल्लेख करता हूं क्योंकि कल्पना कहती है "दोनों समय के मूल्यों में कम से कम 0.1 सेकंड की सटीकता होनी चाहिए।"
प्रहार

1
आप long इससे पहले कि हटा सकते हैं sऔर कुछ बाइट्स को बचाने ,sके static long t,i,s;लिए जोड़ सकते हैं ।
केविन क्रूज़सेन

2

सी (pthreads के साथ), 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);}

2

C90 (ओपनएमपी), 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 / सेकंड) में है, इसलिए कार्यक्रम 70 सेकंड तक चला

बहुत कम हो सकता है अगर मुझे omp_get_wtime () के अलावा अन्य काम करने के लिए टाइमर प्राप्त करने का एक तरीका मिल गया है क्योंकि तब मैं इसमें शामिल विवरण को हटा सकता हूं।

OMP_NUM_THREADS = 9 के साथ चलाएँ


आप env var सेट कर सकते हैं, लेकिन आपको ऐसा करने के लिए बाइट्स की गणना करनी होगी, सिवाय इसके कि आपके द्वारा चुनी गई सेटिंग एक सामान्य डिफ़ॉल्ट है।
18

@ Adám धन्यवाद, यही मैंने सोचा था, यह 6 या 7 बाइट्स बचाता है
dj0wns

2

आम लिस्प (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 से अधिक टिक (यानी 60 के दशक के sbcl) पर होता है। काउंटर को एक सूची में संग्रहीत किया जाता है, क्योंकि परमाणु-इंकफ़ के स्थानों की सीमाओं को संशोधित किया जा सकता है। यह तेजी से मशीनों पर समाप्त होने से पहले अंतरिक्ष से बाहर चला सकता है।

Ungolfed:

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

2

पर्ल, 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

1

ग्रोवी, 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]

1

अमृत, 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समय को मापने के लिए उपयोग करता है ।


समुदाय में आपका स्वागत है !!
निकली आउटगॉल्फ

1

हास्केल, 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, यह देखते हुए कार्रवाई एन बार पुन: दोहरा (और लौटने tक्योंकि गोल्फ)।

मापा भाग के अंदर, 9 धागे ( replicate 9 $ forkIO ...) 5^10मिलीसेकंड (9.765625 सेकंड) के लिए सोते हैं और परिणाम ( writeChan) को मुख्य धागे द्वारा बनाए गए पाइप पर पोस्ट करते हैं ( newChan), जो 9 परिणामों को पूरा करता है और कुल प्रिंट करता है ( getChanContents >>= print . sum . take 9)।

आउटपुट:

87.938546708s
9.772032144s

1
@ Adám 6 ^ 9> 10 ^ 7 (10 सेकंड)।
कोटरपिलर

1

पायथन 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

1

रूबी ( parallelमणि के साथ ), 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 द्वारा रूबी जवाब से "Time.now" संदर्भ जोड़ा गया।


1

मतलाब, 75 बाइट्स

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

त्वरित स्पष्टीकरण: parforश्रमिकों के पूल में वितरित किए गए समानांतर-पाश बनाता है। ticऔर tocबीता हुआ समय मापें (और मेरी राय में MATLAB में सबसे अच्छे नामित कार्यों में से एक हैं)। अंतिम पंक्ति (कुल समय के साथ एक सरणी सो गई और वास्तविक समय समाप्त हो गया) आउटपुट है क्योंकि यह अर्धविराम के साथ समाप्त नहीं हुआ है।

ध्यान दें कि यह एक पूर्ण 9 पूर्ण MATLAB प्रक्रियाओं बनाता है। संभावना है कि यह विशेष कार्यक्रम यह आपके मशीन पर आवंटित 10 सेकंड के भीतर खत्म नहीं होगा। हालाँकि, मुझे लगता है कि एक MATLAB इंस्टॉलेशन के साथ जिसमें कोई टूलबॉक्स नहीं है सिवाय समानांतर कम्प्यूटिंग टूलबॉक्स के - एसएसडी के साथ उच्च-एंड सिस्टम पर स्थापित - केवल 10 सेकंड के भीतर समाप्त करने में सक्षम हो सकता है। यदि आवश्यक हो, तो आप मापदंडों को कम कर सकते हैं ताकि कम प्रक्रियाएं अधिक सो सकें।


के बारे bमें त्रुटि की संभावना सिर्फ इसलिए है क्योंकि आपके पास अपने कार्यक्षेत्र में पहले से ही कुछ था। मैं 2015b पर कोई मुद्दों का उपयोग करparfor q=b
Suever

@Suever ओह हे, मेरे पास मेरे MATLAB फ़ोल्डर में bm नाम की एक स्क्रिप्ट थी।
सानचिस
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.