Compito

Utilizzando qualsiasi tipo di parallelizzazione, attendere più periodi, per un tempo di sonno totale di almeno un minuto (ma meno di un minuto e mezzo).

Il programma / funzione deve terminare entro 10 secondi e restituire (in qualsiasi modo e in qualsiasi formato) due valori: il tempo totale trascorso e il tempo di sospensione totale eseguito. Entrambi i valori temporali devono avere una precisione di almeno 0,1 secondi.

Questo è simile al concetto di ore-uomo : un lavoro che richiede 60 ore può essere completato in sole 6 ore se 10 lavoratori stanno dividendo il lavoro. Qui possiamo avere 60 secondi di tempo di sospensione, ad esempio in 10 thread paralleli, richiedendo quindi solo 6 secondi per il completamento dell'intero lavoro.

Esempio

Il programma MyProgram crea 14 thread, ogni thread dorme per 5 secondi:

MyProgram → [5.016,70.105]

Il tempo di esecuzione è maggiore di 5 secondi e il tempo totale di sospensione è maggiore di 70 secondi a causa dell'overhead.

Dyalog APL, 65 27 23 21 byte

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

Vale a dire:

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

Spiegazione:

• ⎕DL&¨9/7: stacca 9 fili, ognuno dei quali attende 7 secondi. ⎕DLrestituisce il tempo effettivo trascorso in attesa, in secondi, che sarà lo stesso del suo argomento dato o impiegato alcuni millisecondi.
• ⎕TSYNC: attendi il completamento di tutti i thread e ottieni il risultato per ogni thread.
• (⌈/,+/): restituisce il tempo di esecuzione più lungo di un singolo thread (durante l'esecuzione del quale sono terminati tutti gli altri thread, quindi questo è il tempo di esecuzione effettivo), seguito dalla somma del tempo di esecuzione di tutti i thread.

Provalo online!

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

Ciò richiede un sistema operativo con una precisione temporale superiore a 1 secondo per funzionare correttamente (in altre parole, qualsiasi sistema operativo moderno). Vengono creati 8 thread che dormono per 9 secondi ciascuno, con un tempo di esecuzione di ~ 9 secondi in tempo reale e un tempo di esecuzione parallelo di ~ 72 secondi.

Sebbene la documentazione ufficiale affermi che il Threadcostruttore dovrebbe essere chiamato con argomenti di parole chiave, lancio cautela nel vento e utilizzo comunque argomenti posizionali. Il primo argomento ( group) deve essere Nonee il secondo argomento è la funzione target.

nneonneo ha sottolineato nei commenti che l'accesso agli attributi (ad es. f.t) è più breve dell'accesso all'indice dell'elenco (ad es t[0].). Sfortunatamente, nella maggior parte dei casi, i pochi byte guadagnati da questa operazione andrebbero persi con la necessità di creare un oggetto che consenta di creare attributi definiti dall'utente in fase di esecuzione. Fortunatamente, le funzioni supportano gli attributi definiti dall'utente in fase di esecuzione, quindi lo sfrutto risparmiando il tempo totale tnell'attributo di f.

Provalo online

Grazie a DenkerAffe per -5 byte con il exectrucco.

Grazie a Kundor per -7 byte sottolineando che l'argomento thread non è necessario.

Grazie a nneonneo per -7 byte da vari miglioramenti.

Utilità Bash + GNU, 85

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

Forza l'uso timedell'eseguibile anziché della shell incorporata con il prefisso a \.

Si aggiunge a un file j, che deve essere vuoto o inesistente all'inizio.

Vai - 189 byte

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

Uscite (ms): 160.9939ms, 60001 (160ms per attendere 60.001 secondi)

Bash 196 117 114 93 byte

Aggiornato per supportare una migliore precisione temporale integrando i suggerimenti di @manatwork e @Digital Trauma e alcune altre ottimizzazioni dello spazio:

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

Si noti che ciò presuppone che il jfile sia assente all'inizio.

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

Promette di aspettare 9 volte per 7 secondi per un totale di 63 secondi (in realtà 63.43 quando provo), ma in realtà richiede solo 7,05 secondi di tempo reale quando provo.

C, 127 byte (gira CPU)

Questa soluzione fa girare la CPU invece di dormire e conta il tempo usando la timesfunzione POSIX (che misura il tempo della CPU consumato dal processo genitore e in tutti i figli attesi).

Rinvia 7 processi che ruotano per 9 secondi ciascuno e stampa i tempi finali in orologi a C (sulla maggior parte dei sistemi, 100 tick di clock = 1 secondo).

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

Uscita campione:

906,6347

significa 9,06 secondi in tempo reale e 63,47 secondi in totale CPU.

Per risultati ottimali, compilare con -std=c90 -m32(forza il codice a 32 bit su una macchina a 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

Imposta $duguale a Get-Datee cancella tutte le storie di lavoro esistenti con Get-Job | Remove-Job. Quindi eseguiamo il loop 1..20|%{...}e ogni iterazione viene eseguita Start-Jobpassando il blocco di script {$x=date;sleep 3;((date)-$x).ticks/1e7}per il processo (il che significa che ogni processo eseguirà quel blocco di script). Effettuiamo il piping dell'output per >$nullsopprimere il feedback (ad esempio, nome lavoro, stato, ecc.) Che viene restituito.

Il blocco di script viene impostato $xsu Get-Date, quindi Start-Sleepper 3secondi, quindi richiede una nuova Get-Datelettura, sottrae $x, ottiene il .Tickse si divide 1e7per ottenere i secondi (con precisione).

Di nuovo nel thread principale, fintanto che qualsiasi lavoro è ancora -Status "Running", giriamo all'interno di un whileloop vuoto . Una volta fatto ciò, Get-Jobtiriamo su gli oggetti per tutti i lavori esistenti, reindirizziamo quelli a Receive-Jobcui tirerà su l'equivalente di STDOUT (cioè, ciò che producono), -joini risultati insieme +e lo colleghiamo a iex( Invoke-Expressione simili a eval). Questo produrrà il tempo di sonno risultante più spese generali.

La riga finale è simile, in quanto ottiene una nuova data, sottrae l'indicatore della data originale $d, ottiene il .Tickssimbolo e si divide 1e7per generare il tempo di esecuzione totale.

NB

OK, quindi questo è un po ' flessibile delle regole. Apparentemente alla prima esecuzione, PowerShell deve caricare un sacco di assembly .NET dal disco per le varie operazioni del thread poiché non sono caricati con il profilo shell predefinito. Le esecuzioni successive , poiché gli assembly sono già in memoria, funzionano correttamente. Se si lascia la finestra della shell inattiva abbastanza a lungo, si otterrà la garbage collection integrata di PowerShell per scaricare e scaricare tutti quegli assembly, facendo sì che l'esecuzione successiva richieda molto tempo mentre li ricarica. Non sono sicuro di un modo per aggirare questo.

Puoi vederlo nei tempi di esecuzione nelle esecuzioni sottostanti. Ho avviato una nuova shell, ho navigato nella mia directory di golf ed eseguito lo script. La prima manche è stata orrenda, ma la seconda (eseguita immediatamente) ha funzionato bene. Ho quindi lasciato la shell inattiva per alcuni minuti per far passare la garbage collection, e poi quella corsa è di nuovo lunga, ma le successive corse funzionano di nuovo bene.

L'esempio funziona

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

Questo codice crea 10 immagini con un intervallo di tempo di esattamente 6 secondi ciascuna, al momento del caricamento.

Il tempo di esecuzione supera di poco (a causa delle spese generali).

Questo codice sovrascrive tutto nel documento!

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)

Ciò presuppone che si utilizzi una codifica a byte singolo per i backtick, che è necessario per il motore Javascript per non inciampare.

In alternativa, se non vuoi aspettare 6 secondi in attesa, ecco una soluzione di 1 byte più lunga che termina in meno di un secondo:

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)

La differenza è che questo codice attende 600ms su 100 immagini. Ciò fornirà una quantità enorme di spese generali.

Vecchia versione (203 byte):

Questo codice crea 10 iframe con un intervallo di tempo esattamente di 6 secondi ciascuno, invece di creare 10 immagini.

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)

Versione originale (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

Sto facendo una nuova risposta poiché utilizza un approccio leggermente diverso.

Genera una quantità enorme di setTimeouts, che sono quasi tutti eseguiti con 4ms tra di loro.

Ogni intervallo è di 610 millisecondi, per un totale di 99 intervalli.

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

Di solito viene eseguito entro 610 ms, per un tempo di esecuzione totale di circa 60,5 secondi.

Questo è stato testato su Google Chrome versione 51.0.2704.84 m, su Windows 8.1 x64.

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

Scratch - 164 byte (16 blocchi)

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

Guardalo in azione qui .

Usa una variabile chiamata 't' e uno sprite chiamato 's'. Lo sprite crea cloni di se stesso, ciascuno dei quali attende 8 secondi, e incrementa una variabile che cronometra l'intero tempo di attesa. Alla fine indica il tempo di esecuzione totale e il tempo di attesa totale (ad esempio 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)])

Versione formattata con variabili denominate:

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

uscita (in nanosecondi):

[62999772966 7001137032]

Formato modificato. Grazie Adám, potrei aver perso quella specifica di formato nella domanda quando l'ho letta.

Modificato in nanoTime per le abilità di golf.

Grazie cliffroot, mi sono completamente dimenticato della notazione scientifica e non riesco a credere di non aver visto apply. Penso di averlo usato in qualcosa che stavo giocando a golf ieri ma non ho mai pubblicato. Mi hai salvato 2 byte.

Ruggine, 257 , 247 byte

Uso le stesse volte della risposta Python di Mego.

In realtà l'unico bit leggermente intelligente sta usando ii per ottenere una durata di 0 secondi.

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

stampe:

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

Modifica: il buon vecchio per loop è un po 'più breve

JavaScript (ES6, utilizzando 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: sostituito il modo in cui un lavoratore viene eseguito da una stringa con una più compatta e multi-browser, nell'aspetto delle politiche di origine incrociata. Non funzionerà in Safari, se ha ancora webkitURLoggetto invece di URL, e in 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

Questa è una derivazione della risposta di Mego, ma è sufficientemente diversa che ho pensato che dovesse essere una risposta separata. È testato per funzionare su Windows.

Fondamentalmente, elimina 9 thread, che dormono per 7 secondi mentre il genitore dorme per 8. Quindi stampa i tempi. Uscita campione:

8.00059192923 71.0259046024

Su Windows, time.clockmisura il tempo di wall dalla prima chiamata.

Perl 6, 72 71 byte

Potrebbe esserci un modo più breve per farlo

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

questo produce

63.00660729694
7.0064013

Mathematica, 109 byte

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

Funzione anonima. Richiede una licenza con almeno 7 kernel secondari per l'esecuzione. Richiede 9 secondi in tempo reale e 63 secondi nel kernel-time, senza tenere conto delle spese generali. Assicurati di eseguire le istruzioni precedenti una sola volta (quindi non prova a riavviare i kernel). test:

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)

Versione aggiornata: 106 byte Presi in prestito da @Ismael Miguel perché aveva la grande idea di ridurre il tempo di sonno e aumentare gli intervalli.

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

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

per favore non provarlo a casa, poiché questa soluzione non è thread-safe.

Modificare:

Ho seguito i suggerimenti di @A Boschman e @ Adám e ora il mio programma richiede meno di 10 secondi per essere eseguito, ed è più breve di 15 byte.

C (con 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 per variabile 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);}

Esempio di output:

7091,9.000014

Appunti:

7091 è in cicli (100 / sec), quindi il programma ha funzionato per 70 secondi

Potrebbe essere molto più breve se immaginassi un modo per far funzionare un timer diverso da omp_get_wtime () perché potrei rimuovere anche l'istruzione include.

Esegui con OMP_NUM_THREADS = 9

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

Questo genera appena thread che dormono e quindi aumentano atomicamente il tempo impiegato, con un loop esterno che gira in attesa che il tempo totale sia più di 60000 tick (cioè 60s su sbcl). Il contatore è memorizzato in un elenco a causa delle limitazioni ai tipi di posizioni che atomic-incf può modificare. Questo potrebbe esaurire lo spazio prima di terminare su macchine più veloci.

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

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

Forks 7 processi figlio, ognuno dei quali attende 9 secondi.

Uscita campione:

perl wait-one-minute.pl
9.00925707817078-63.001741

Groovy, 158 143 caratteri

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

Esecuzione di esempio:

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

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

Esecuzione di esempio:

$ elixir thing.exs
64012846
4007547

L'output è il tempo totale atteso seguito dal tempo di esecuzione del programma, in microsecondi.

Il programma genera 14 Tasksecondi e li attende mappandoli su di essi, quindi trova la somma del loro tempo trascorso. Usa Erlang timerper misurare il tempo.

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

!misura il tempo impiegato dall'azione a(secondo argomento) e applica b(primo argomento) al risultato.

w è la funzione sleep.

mainviene misurato e il risultato viene stampato ( print!...).

#è replicateM, ripetendo l'azione data N volte (e ritornando tperché giocare a golf).

All'interno della parte misurata, 9 thread ( replicate 9 $ forkIO ...) dormono per 5^10millisecondi (9.765625 secondi) e pubblicano il risultato ( writeChan) in una pipe creata dal thread principale ( newChan), che somma i 9 risultati e stampa il totale ( getChanContents >>= print . sum . take 9).

Produzione:

87.938546708s
9.772032144s

Python 2, 132 byte

Utilizza un pool di processi per generare 9 processi e lasciarli in pausa per 7 secondi.

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

Stampa prima il tempo di sonno totale accumulato, quindi il tempo di esecuzione effettivo:

$ python test.py
63.0631158352 7.04391384125

Rubino (con parallelgemma), 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

Modifica: aggiunto il riferimento "Time.now" dalla risposta di Ruby dell'istocratico.

Matlab, 75 byte

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

Spiegazione rapida: parforcrea un ciclo continuo parallelo, distribuito nel pool di lavoratori. tice tocmisurare il tempo trascorso (e secondo me è una delle funzioni meglio denominate in MATLAB). L'ultima riga (un array con il tempo totale dormito e il tempo reale trascorso) viene emessa poiché non è terminata con un punto e virgola.

Si noti tuttavia che ciò crea un enorme 9 processi MATLAB a tutti gli effetti. È quindi probabile che questo particolare programma non finisca entro i 10 secondi assegnati sulla macchina. Tuttavia, penso che con un'installazione MATLAB che non abbia toolbox tranne la toolbox Parallel Computing installata - installata su un sistema di fascia alta con SSD - potrebbe essere in grado di terminare entro 10 secondi. Se necessario, è possibile modificare i parametri per avere meno processi che dormono di più.