Tarea

Usando cualquier tipo de paralelización, espere varios períodos, para un tiempo total de sueño de al menos un minuto (pero menos de un minuto y medio).

El programa / función debe finalizar dentro de los 10 segundos y devolver (por cualquier medio y en cualquier formato) dos valores: el tiempo total transcurrido y el tiempo total de suspensión ejecutado. Ambos valores de tiempo deben tener una precisión de al menos 0.1 segundos.

Esto es similar al concepto de horas hombre : un trabajo que lleva 60 horas se puede completar en solo 6 horas si 10 trabajadores están dividiendo el trabajo. Aquí podemos tener 60 segundos de tiempo de suspensión, por ejemplo, en 10 subprocesos paralelos, lo que requiere solo 6 segundos para completar todo el trabajo.

Ejemplo

El programa MyProgram crea 14 hilos, cada hilo duerme durante 5 segundos:

MyProgram → [5.016,70.105]

El tiempo de ejecución es superior a 5 segundos y el tiempo de suspensión total es superior a 70 segundos debido a la sobrecarga.

Dyalog APL, 65 27 23 21 bytes

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

Es decir:

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

Explicación:

• ⎕DL&¨9/7: separa 9 hilos, cada uno de los cuales espera 7 segundos. ⎕DLdevuelve la cantidad real de tiempo de espera, en segundos, que será el mismo que su argumento da o toma unos pocos milisegundos.
• ⎕TSYNC: espere a que se completen todos los hilos y obtenga el resultado de cada hilo.
• (⌈/,+/): devuelve el tiempo de ejecución más largo de un solo subproceso (durante la ejecución de la cual finalizaron todos los demás subprocesos, por lo que este es el tiempo de ejecución real), seguido de la suma del tiempo de ejecución de todos los subprocesos.

Pruébalo en línea!

Python 2, 172 bytes

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

Esto requiere un sistema operativo con una precisión de tiempo superior a 1 segundo para funcionar correctamente (en otras palabras, cualquier sistema operativo moderno). Se crean 8 hilos que duermen durante 9 segundos cada uno, lo que resulta en un tiempo de ejecución en tiempo real de ~ 9 segundos y un tiempo de ejecución paralelo de ~ 72 segundos.

Aunque la documentación oficial dice que Threaddebe llamarse al constructor con argumentos de palabras clave, de todos modos tengo precaución y uso argumentos posicionales. El primer argumento ( group) debe ser None, y el segundo argumento es la función objetivo.

nneonneo señaló en los comentarios que el acceso al atributo (p f.t. ej. ) es más corto que el acceso al índice de la lista (p t[0]. ej .). Desafortunadamente, en la mayoría de los casos, los pocos bytes obtenidos al hacer esto se perderían al necesitar crear un objeto que permita crear atributos definidos por el usuario en tiempo de ejecución. Afortunadamente, las funciones admiten atributos definidos por el usuario en tiempo de ejecución, por lo que aprovecho esto al guardar el tiempo total en el tatributo de f.

Pruébalo en línea

Gracias a DenkerAffe por -5 bytes con el exectruco.

Gracias a kundor por -7 bytes al señalar que el argumento del hilo es innecesario.

Gracias a nneonneo por -7 bytes de mejoras diversas.

Bash + utilidades GNU, 85

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

Fuerza el uso del timeejecutable en lugar del shell incorporado al prefijar con a \.

Se agrega a un archivo j, que debe estar vacío o inexistente al inicio.

Ir - 189 bytes

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

Salidas (ms): 160.9939ms, 60001 (160ms para esperar 60.001 segundos)

Bash 196 117 114 93 bytes

Actualizado para admitir una mejor precisión de tiempo mediante la integración de sugerencias de @manatwork y @Digital Trauma, así como algunas otras optimizaciones de espacio:

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

Tenga en cuenta que esto supone que el jarchivo está ausente al principio.

JavaScript (ES6), 148 bytes

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

Promete esperar 9 veces durante 7 segundos por un total de 63 segundos (en realidad 63.43 cuando lo intento), pero solo toma 7.05 segundos de tiempo real cuando lo intento.

C, 127 bytes (gira la CPU)

Esta solución hace girar la CPU en lugar de dormir, y cuenta el tiempo usando la timesfunción POSIX (que mide el tiempo de CPU consumido por el proceso padre y en todos los niños esperados).

Bifurca 7 procesos que giran durante 9 segundos cada uno e imprime los tiempos finales en los relojes C (en la mayoría de los sistemas, 100 tics de reloj = 1 segundo).

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

Salida de muestra:

906,6347

es decir, 9,06 segundos en tiempo real y 63,47 segundos de tiempo total de CPU.

Para obtener mejores resultados, compile con -std=c90 -m32(forzar código de 32 bits en una máquina de 64 bits).

PowerShell v4, 144 bytes

$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

Establece $digual a Get-Date, y borra cualquier historial de trabajo existente con Get-Job | Remove-Job. Luego realizamos un ciclo 1..20|%{...}y cada iteración se ejecuta Start-Jobpasándole el bloque de script {$x=date;sleep 3;((date)-$x).ticks/1e7}para el trabajo (lo que significa que cada trabajo ejecutará ese bloque de script). Canalizamos esa salida para >$nullsuprimir la retroalimentación (es decir, nombre del trabajo, estado, etc.) que se devuelve.

El bloque de secuencia de comandos se establece $xen Get-Date, luego Start-Sleepdurante 3segundos, luego toma una nueva Get-Datelectura, resta $x, obtiene el .Ticksy divide por 1e7para obtener los segundos (con precisión).

De vuelta en el hilo principal, siempre y cuando cualquier trabajo siga siendo -Status "Running", giramos dentro de un whilebucle vacío . Una vez hecho esto, debemos Get-Jobextraer los objetos para todos los trabajos existentes, canalizar aquellos a los Receive-Jobque extraerá el equivalente de STDOUT (es decir, lo que generan), -joinlos resultados junto con +, y canalizarlo a iex( Invoke-Expressiony similar a eval). Esto generará el tiempo de suspensión resultante más los gastos generales.

La línea final es similar, ya que obtiene una nueva fecha, resta el sello de fecha original $d, obtiene el .Ticksy divide por 1e7para generar el tiempo total de ejecución.

nótese bien

Bien, esto es un poco incómodo con las reglas. Aparentemente, en la primera ejecución, PowerShell necesita cargar un conjunto de ensamblados .NET desde el disco para las diversas operaciones de subproceso, ya que no se cargan con el perfil de shell predeterminado. Las ejecuciones posteriores , debido a que los ensamblados ya están en la memoria, funcionan bien. Si deja la ventana de shell inactiva el tiempo suficiente, obtendrá la recolección de basura incorporada de PowerShell y descargará todos esos ensamblajes, lo que hará que la próxima ejecución tarde mucho tiempo ya que los vuelve a cargar. No estoy seguro de una forma de evitar esto.

Puede ver esto en los tiempos de ejecución en las siguientes ejecuciones. Comencé un nuevo shell, navegué a mi directorio de golf y ejecuté el script. La primera ejecución fue horrenda, pero la segunda (ejecutada inmediatamente) funcionó bien. Luego dejé el shell inactivo durante unos minutos para dejar pasar la recolección de basura, y luego esa ejecución es nuevamente larga, pero las ejecuciones posteriores nuevamente funcionan bien.

Ejecuciones de ejemplo

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 bytes

Este código crea 10 imágenes con un intervalo de tiempo de exactamente 6 segundos cada una, al cargarse.

El tiempo de ejecución va un poco por encima (debido a la sobrecarga).

¡Este código sobrescribe todo en el 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)

Esto supone que usa una codificación de un solo byte para los backticks, lo cual es necesario para que el motor Javascript no se dispare.

Alternativamente, si no desea pasar 6 segundos esperando, aquí hay una solución de 1 byte más que termina en menos de un segundo:

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 diferencia es que este código espera 600 ms en 100 imágenes. Esto le dará una gran cantidad de gastos generales.

Versión anterior (203 bytes):

Este código crea 10 iframes con un intervalo de tiempo de exactamente 6 segundos cada uno, en lugar de crear 10 imágenes.

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ón original (212 bytes):

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 bytes

Estoy haciendo una nueva respuesta ya que esto utiliza un enfoque ligeramente diferente.

Genera una cantidad masiva de setTimeouts, que casi todos se ejecutan con 4 ms entre ellos.

Cada intervalo es de 610 milisegundos, en un total de 99 intervalos.

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

Por lo general, se ejecuta dentro de 610 ms, para un tiempo de ejecución total de alrededor de 60.5 segundos.

Esto se probó en Google Chrome versión 51.0.2704.84 m, en Windows 8.1 x64.

Versión anterior (108 bytes):

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 bytes (16 bloques)

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

Véalo en acción aquí .

Utiliza una variable llamada 't' y un sprite llamado 's'. El sprite crea clones de sí mismo, cada uno de los cuales espera 8 segundos, e incrementa una variable que registra el tiempo de espera completo. Al final dice el tiempo total de ejecución y el tiempo total de espera (por ejemplo 65.488 8.302).

Clojure, 135 120 111 109 bytes

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

Versión formateada con variables con nombre:

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

salida (en nanosegundos):

[62999772966 7001137032]

Se modificó el formato. Gracias Adám, podría haber perdido esa especificación de formato en la pregunta cuando la leí.

Cambiado a nanoTime para habilidades de golf.

Gracias cliffroot, me olvidé por completo de la notación científica y no puedo creer que no haya visto apply. Creo que usé eso en algo que estaba jugando al golf ayer pero que nunca publiqué. Me salvaste 2 bytes.

Óxido, 257 , 247 bytes

Yo uso las mismas veces que la respuesta Python de Mego.

Realmente, el único bit ligeramente inteligente es usar ii para obtener una duración de 0 segundos.

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

Huellas dactilares:

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

Sin golf:

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

Editar: bueno para el bucle es un poco más corto

JavaScript (ES6, utilizando WebWorkers), 233 215 bytes

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: reemplazó la forma en que un trabajador se ejecuta desde una cadena por una más compacta y de navegador cruzado, en el aspecto de las políticas de origen cruzado. No funcionará en Safari, si todavía tiene un webkitURLobjeto en lugar de URL, y en IE.

Python 2, 130 bytes

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

Esta es una derivación de la respuesta de Mego, pero es lo suficientemente diferente como para pensar que debería ser una respuesta separada. Está probado para funcionar en Windows.

Básicamente, bifurca 9 hilos, que duermen durante 7 segundos mientras el padre duerme durante 8. Luego imprime los tiempos. Salida de muestra:

8.00059192923 71.0259046024

En Windows, time.clockmide el tiempo de pared desde la primera llamada.

Perl 6, 72 71 bytes

Puede haber una forma más corta de hacer esto

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

esto produce

63.00660729694
7.0064013

Mathematica, 109 bytes

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

Función anónima. Requiere una licencia con más de 7 sub-núcleos para ejecutarse. Toma 9 segundos en tiempo real y 63 segundos en tiempo de kernel, sin tener en cuenta los gastos generales. Asegúrese de ejecutar solo las declaraciones anteriores una vez (para que no intente reiniciar los núcleos). Pruebas:

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 bytes

((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ón actualizada: 106 bytes Prestada de @Ismael Miguel ya que tuvo la gran idea de reducir el tiempo de sueño y aumentar los intervalos.

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

(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, 358343 337 316 313 bytes

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

y sin golf

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

no lo intentes en casa, ya que esta solución no es segura para subprocesos.

Editar:

Tomé las sugerencias de @A Boschman y @ Adám, y ahora mi programa requiere menos de 10 segundos para ejecutarse, y es más corto en 15 bytes.

C (con subprocesos), 339 336 335 bytes

#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 Bytes (+ 17 para la variable 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);}

Salida de ejemplo:

7091,9.000014

Notas:

7091 está en ciclos (100 / seg), por lo que el programa se ejecutó durante 70 segundos

Podría ser mucho más corto si descubriera una forma de hacer que un temporizador funcione aparte de omp_get_wtime () porque entonces también podría eliminar la declaración de inclusión.

Ejecutar con OMP_NUM_THREADS = 9

Lisp común (SBCL) 166 bytes:

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

Esto solo genera hilos que duermen y luego aumentan atómicamente el tiempo necesario, con un bucle externo que gira esperando que el tiempo total sea más de 60000 tics (es decir, 60 s en sbcl). El contador se almacena en una lista debido a limitaciones en los tipos de lugares que atomic-incf puede modificar. Esto puede quedarse sin espacio antes de terminar en máquinas más rápidas.

Sin golf:

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

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

Bifurca 7 procesos secundarios, cada uno de los cuales espera 9 segundos.

Salida de muestra:

perl wait-one-minute.pl
9.00925707817078-63.001741

Groovy, 158 143 caracteres

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

Ejecución de muestra:

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

Elixir, 168 bytes

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)

Ejecución de muestra:

$ elixir thing.exs
64012846
4007547

La salida es el tiempo total esperado seguido por el tiempo que el programa se ha ejecutado, en microsegundos.

El programa genera 14 Tasks, y espera a cada uno de ellos mediante un mapeo sobre ellos, y luego encuentra la suma de su tiempo transcurrido. Utiliza Erlang's timerpara medir el tiempo.

Haskell, 278 271 262 246 bytes

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

!mide el tiempo empleado por la acción a(segundo argumento) y se aplica b(primer argumento) al resultado.

w Es la función del sueño.

mainse mide y el resultado se imprime ( print!...).

#es decir replicateM, repitiendo la acción dada N veces (y regresando tdebido al golf).

Dentro de la parte medida, 9 hilos ( replicate 9 $ forkIO ...) duermen durante 5^10milisegundos (9.765625 segundos) y publican el resultado ( writeChan) en una tubería creada por el hilo principal ( newChan), que suma los 9 resultados e imprime el total ( getChanContents >>= print . sum . take 9).

Salida:

87.938546708s
9.772032144s

Python 2, 132 bytes

Utiliza un grupo de procesos para generar 9 procesos y dejar que cada uno duerma durante 7 segundos.

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

Imprime el tiempo de sueño total acumulado primero, luego el tiempo de ejecución real:

$ python test.py
63.0631158352 7.04391384125

Rubí (con parallelgema), 123116 bytes

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

Editar: se agregó la referencia "Time.now" de la respuesta Ruby de histocrat.

Matlab, 75 bytes

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

Explicación rápida: parforcrea un bucle for paralelo, distribuido en el grupo de trabajadores. ticy tocmedir el tiempo transcurrido (y en mi opinión son una de las funciones mejor nombradas en MATLAB). La última línea (una matriz con el tiempo total dormido y el tiempo real transcurrido) se emite ya que no termina con un punto y coma.

Sin embargo, tenga en cuenta que esto crea la friolera de 9 procesos MATLAB completos. Es probable que este programa en particular no termine dentro de los 10 segundos asignados en su máquina. Sin embargo, creo que con una instalación de MATLAB que no tiene cajas de herramientas a excepción de la caja de herramientas de Computación Paralela instalada, instalada en un sistema de alta gama con SSD, es posible que pueda terminar en 10 segundos. Si es necesario, puede ajustar los parámetros para que menos procesos duerman más.