Tâche

En utilisant n'importe quel type de parallélisation, attendez plusieurs périodes, pour une durée totale de sommeil d'au moins une minute (mais inférieure à une minute et demie).

Le programme / la fonction doit se terminer dans les 10 secondes et renvoyer (par n'importe quel moyen et dans n'importe quel format) deux valeurs: le temps total écoulé et le temps total de sommeil exécuté. Les deux valeurs de temps doivent avoir une précision d'au moins 0,1 seconde.

Ceci est similaire au concept d' heures de travail : un travail de 60 heures peut être achevé en seulement 6 heures si 10 travailleurs se séparent. Ici, nous pouvons disposer de 60 secondes de temps de repos, par exemple dans 10 threads parallèles, ne nécessitant que 6 secondes pour que le travail complet soit terminé.

Exemple

Le programme MyProgram crée 14 threads, chaque thread dort pendant 5 secondes:

MyProgram → [5.016,70.105]

Le temps d'exécution est supérieur à 5 secondes et le temps total de veille est supérieur à 70 secondes en raison de la surcharge.

Dyalog APL, 65 27 23 21 octets

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

C'est à dire:

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

Explication:

• ⎕DL&¨9/7: essore 9 fils, chacun attend 7 secondes. ⎕DLrenvoie le temps réel passé en attente, en secondes, qui sera identique à son argument donner ou prendre quelques millisecondes.
• ⎕TSYNC: attendez que tous les threads soient terminés et obtenez le résultat pour chaque thread.
• (⌈/,+/): renvoie le temps d'exécution le plus long d'un seul thread (pendant l'exécution de tous les autres threads, il s'agit donc du temps d'exécution réel), suivi de la somme du temps d'exécution de tous les threads.

Essayez-le en ligne!

Python 2, 172 octets

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

Cela nécessite un système d'exploitation avec une précision temporelle supérieure à 1 seconde pour fonctionner correctement (en d'autres termes, tout système d'exploitation moderne). On crée 8 threads qui dorment chacun pendant 9 secondes, ce qui donne un temps d'exécution en temps réel d'environ 9 secondes et un temps d'exécution parallèle d'environ 72 secondes.

Bien que la documentation officielle indique que le Threadconstructeur devrait être appelé avec des arguments de mot-clé, je jette la prudence au vent et utilise quand même des arguments de position. Le premier argument ( group) doit être None, et le deuxième argument est la fonction cible.

Nneonneo a souligné dans les commentaires que l'attribut access (eg f.t) est plus court que l'accès list index (eg t[0]). Malheureusement, dans la plupart des cas, les quelques octets générés par cette opération seraient perdus s'il était nécessaire de créer un objet permettant de créer des attributs définis par l'utilisateur au moment de l'exécution. Heureusement, les fonctions supportent les attributs définis par l'utilisateur au moment de l'exécution. Je l'exploite donc en enregistrant le temps total dans l' tattribut de f.

Essayez-le en ligne

Merci à DenkerAffe pour -5 octets avec le exectruc.

Merci à kundor pour -7 octets en soulignant que l'argument du fil n'est pas nécessaire.

Merci à nneonneo pour -7 octets de diverses améliorations.

Utilitaires Bash + GNU, 85

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

Force l'utilisation de l' timeexécutable au lieu du shell intégré en préfixant avec un \.

S'ajoute à un fichier jqui doit être vide ou inexistant au début.

Go - 189 octets

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

Sorties (ms): 160.9939ms, 60001 (160ms à attendre 60.001 secondes)

Bash 196 117 114 93 octets

Mise à jour pour permettre une meilleure précision temporelle en intégrant les suggestions de @manatwork et de @Digital Trauma, ainsi que quelques autres optimisations d'espace:

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

Notez que cela suppose que le jfichier est absent au début.

JavaScript (ES6), 148 octets

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

Promet d'attendre 9 fois pendant 7 secondes pour un total de 63 secondes (en fait 63,43 lorsque j'essaie), mais ne prend en réalité que 7,05 secondes de temps réel lorsque j'essaie.

C, 127 octets (tourne le processeur)

Cette solution permet au processeur de tourner au lieu de s’endormir et de comptabiliser le temps à l’aide de la timesfonction POSIX (qui mesure le temps de traitement consommé par le processus parent et dans tous les enfants en attente).

Il supprime 7 processus qui tournent chacun pendant 9 secondes et imprime les temps finaux en horloge C (sur la plupart des systèmes, 100 signaux d'horloge = 1 seconde).

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

Exemple de sortie:

906,6347

ce qui signifie 9,06 secondes en temps réel et 63,47 secondes de temps CPU total.

Pour de meilleurs résultats, compilez avec -std=c90 -m32(forcez du code 32 bits sur une machine 64 bits).

PowerShell v4, 144 octets

$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éfinit $dégal à Get-Date, et efface tous les historiques de travaux existants avec Get-Job | Remove-Job. Nous effectuons ensuite une boucle 1..20|%{...}et chaque exécution exécute en lui Start-Jobpassant le bloc de script {$x=date;sleep 3;((date)-$x).ticks/1e7}pour le travail (ce qui signifie que chaque travail exécutera ce bloc de script). Nous dirigeons cette sortie vers >$nullafin de supprimer le retour (c.-à-d. Nom du travail, statut, etc.) qui est renvoyé.

Le bloc de script se met $xà Get-Date, puis Start-Sleeppendant des 3secondes, puis effectue une nouvelle Get-Datelecture, soustrait $x, obtient le .Ticks, et divise par 1e7pour obtenir les secondes (avec précision).

De retour dans le thread principal, tant que tout travail est toujours -Sactif "Running", nous tournons à l' intérieur d'une whileboucle vide . Une fois que cela est fait, nous devons Get-Jobextraire des objets pour tous les travaux existants, diriger ceux vers Receive-Joblesquels sera extrait l'équivalent de STDOUT (c.-à-d. Ce qu'ils produisent), -joinles résultats ainsi que +, et diriger vers iex( Invoke-Expressionet similaire eval). Cela produira le temps de sommeil résultant plus les frais généraux.

La dernière ligne est similaire, en ce sens qu'elle obtient une nouvelle date, soustrait l'estampille de date d'origine $d, récupère le .Tickset divise par 1e7pour afficher le temps total d'exécution.

NB

OK, donc c'est un peu flou des règles. Apparemment, lors de la première exécution, PowerShell doit charger un groupe d'assemblys .NET à partir du disque pour les différentes opérations de thread, car ils ne sont pas chargés avec le profil de shell par défaut. Les exécutions ultérieures , car les assemblys sont déjà en mémoire, fonctionnent correctement. Si vous laissez la fenêtre du shell inactive suffisamment longtemps, vous obtiendrez la récupération de place intégrée de PowerShell et déchargerez tous ces assemblages, ce qui retardera l'exécution de la prochaine exécution. Je ne suis pas sûr d'un moyen de contourner cela.

Vous pouvez le voir dans les temps d'exécution dans les exécutions ci-dessous. J'ai commencé un nouveau shell, j'ai navigué dans mon répertoire de golf et exécuté le script. La première manche a été horrible, mais la seconde (exécutée immédiatement) a bien fonctionné. J'ai ensuite laissé le shell inactif pendant quelques minutes pour permettre à la récupération de place de se faire, puis l'exécution est à nouveau longue, mais les exécutions suivantes fonctionnent à nouveau correctement.

Exemple fonctionne

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 octets

Ce code crée 10 images avec un intervalle de temps d’exactement 6 secondes lors du chargement.

Le temps d'exécution passe un peu au dessus (à cause des frais généraux).

Ce code écrase tout dans le document!

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)

Cela suppose que vous utilisiez un codage sur un octet pour les backticks, ce qui est nécessaire pour que le moteur Javascript ne se déclenche pas.

Alternativement, si vous ne voulez pas attendre 6 secondes, voici une solution plus longue d'un octet qui se termine en moins d'une seconde:

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 différence est que ce code attend 600 ms sur 100 images. Cela donnera une quantité énorme de frais généraux.

Ancienne version (203 octets):

Ce code crée 10 iframes avec un intervalle de temps de 6 secondes chacun au lieu de créer 10 images.

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)

Version originale (212 octets):

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 octets

Je fais une nouvelle réponse car elle utilise une approche légèrement différente.

Il génère une quantité massive de setTimeouts, qui sont presque tous exécutés à 4 ms les uns des autres.

Chaque intervalle est de 610 millisecondes, sur un total de 99 intervalles.

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

Il s'exécute généralement dans un délai de 610 ms, pour un temps total d'exécution d'environ 60,5 secondes.

Cela a été testé sur Google Chrome version 51.0.2704.84 m, sur Windows 8.1 x64.

Ancienne version (108 octets):

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 octets (16 blocs)

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

Voir en action ici .

Utilise une variable appelée 't' et un sprite appelé 's'. Le sprite crée des clones de lui-même, qui attendent chacun 8 secondes, et incrémente une variable chronométrant tout le temps d'attente. À la fin, il indique le temps total d'exécution et le temps total d'attente (par exemple, 65.488 8.302).

Clojure, 135 120 111 109 octets

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

Version formatée avec des variables nommées:

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

sortie (en nanosecondes):

[62999772966 7001137032]

Format modifié. Merci Adám, j'ai peut-être manqué cette spécification de format dans la question lorsque je l'ai lue.

Changé en nanoTime pour les capacités de golf.

Merci cliffroot, j'ai totalement oublié la notation scientifique et n'arrive pas à croire que je n'ai pas vu apply. Je pense que je l'ai utilisé dans quelque chose que je golfais hier mais que je n'ai jamais posté. Tu m'as sauvé 2 octets.

Rouille, 257 , 247 octets

J'utilise les mêmes temps que la réponse Python de Mego.

Vraiment le seul bit légèrement intelligent utilise ii pour obtenir une durée de 0 secondes.

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

Impressions:

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

Edit: bon vieux pour la boucle est un peu plus courte

JavaScript (ES6, utilisant WebWorkers), 233 215 octets

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: a remplacé la façon dont un opérateur est exécuté à partir d'une chaîne par une chaîne plus compacte et multi-navigateurs, sous l'aspect de stratégies d'origine croisée. Ne fonctionnera pas dans Safari s'il a toujours un webkitURLobjet à la place de URLet dans IE.

Python 2, 130 octets

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

Ceci est une dérivation de la réponse de Mego, mais elle est suffisamment différente pour que je pense que cela devrait être une réponse séparée. Il a été testé pour fonctionner sous Windows.

En gros, il supprime 9 threads, qui dorment pendant 7 secondes, tandis que le parent dort pendant 8 heures. Il affiche ensuite les heures. Exemple de sortie:

8.00059192923 71.0259046024

Sous Windows, time.clockmesure le temps écoulé depuis le premier appel.

Perl 6, 72 71 octets

Il pourrait y avoir un moyen plus court de le faire

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

cette sortie

63.00660729694
7.0064013

Mathematica, 109 octets

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

Fonction anonyme. Nécessite une licence avec 7+ sous-noyaux à exécuter. Cela prend 9 secondes en temps réel et 63 secondes au noyau, sans tenir compte des frais généraux. Assurez-vous de n'exécuter qu'une seule fois les instructions précédentes (afin d'éviter de relancer les noyaux). Essai:

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 octets

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

Version mise à jour: 106 octets Emprunté à @Ismael Miguel, qui a eu la bonne idée de réduire le temps de sommeil et de relever les intervalles.

((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 non codé, 167 octets

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

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

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

veuillez ne pas l'essayer chez vous, car cette solution n'est pas thread-safe.

Modifier:

J'ai pris en compte les suggestions de @A Boschman et de @ Adam, et maintenant, mon programme nécessite moins de 10 secondes pour s'exécuter et il est plus court de 15 octets.

C (avec pthreads), 339 336 335 octets

#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 octets (+ 17 pour la variable env) = 148 octets

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

Exemple de sortie:

7091,9.000014

Remarques:

7091 est en cycles (100 / sec), donc le programme a duré 70 secondes

Cela pourrait être beaucoup plus court si je trouvais un moyen de faire fonctionner un minuteur autre que omp_get_wtime (), car je pourrais alors supprimer l'instruction include également.

Exécuter avec OMP_NUM_THREADS = 9

Common Lisp (SBCL) 166 octets:

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

Cela génère simplement des threads qui dorment puis incrémente le temps pris de manière atomique, avec une boucle externe qui tourne en attendant que le temps total dépasse 60000 ticks (c'est-à-dire 60s sur sbcl). Le compteur est stocké dans une liste en raison de limitations relatives aux types d’endroits que atomic-incf peut modifier. Cela peut manquer d'espace avant de se terminer sur des machines plus rapides.

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 octets

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

Forks 7 processus enfants, chacun attendant 9 secondes.

Exemple de sortie:

perl wait-one-minute.pl
9.00925707817078-63.001741

Groovy, 158 143 caractères

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

Échantillon échantillon:

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

Elixir, 168 octets

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)

Échantillon échantillon:

$ elixir thing.exs
64012846
4007547

La sortie correspond au temps total d'attente suivi du temps d'exécution du programme, en microsecondes.

Le programme génère 14 secondes Tasket attend chacune d’elles en les cartographiant, puis trouve la somme de leur temps écoulé. Il utilise Erlang timerpour mesurer le temps.

Haskell, 278 271 262 246 octets

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

!mesure le temps pris par l'action a(deuxième argument) et applique b(premier argument) au résultat.

w est la fonction de sommeil.

mainest mesurée elle-même et le résultat est imprimé ( print!...).

#est replicateM, répéter l'action donnée N fois (et revenir tparce que jouer au golf).

À l'intérieur de la pièce mesurée, 9 threads ( replicate 9 $ forkIO ...) dorment pendant quelques 5^10millisecondes (9,765625 secondes) et enregistrent le résultat ( writeChan) sur un tuyau créé par le thread principal ( newChan), qui totalise les 9 résultats et affiche le total ( getChanContents >>= print . sum . take 9).

Sortie:

87.938546708s
9.772032144s

Python 2, 132 octets

Utilise un pool de processus pour générer 9 processus et laisser chacun en veille pendant 7 secondes.

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

Affiche le temps de sommeil total accumulé en premier, puis le temps d’exécution réel:

$ python test.py
63.0631158352 7.04391384125

Ruby (avec parallelgemme), 123 116 octets

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

Edit: Ajout de la référence "Time.now" à partir de la réponse Ruby de histocrat.

Matlab, 75 octets

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

Explication rapide: parforcrée une boucle parallèle parallèle, répartie sur le pool de travailleurs. ticet tocmesurez le temps écoulé (et sont à mon avis l’une des fonctions les mieux nommées de MATLAB). La dernière ligne (un tableau avec le temps total écoulé et le temps réel écoulé) est sortie car elle ne se termine pas par un point-virgule.

Notez cependant que cela crée un total de 9 processus MATLAB à part entière. Il est donc probable que ce programme ne se termine pas dans les 10 secondes allouées sur votre ordinateur. Cependant, je pense qu’avec une installation MATLAB qui n’a pas de boîte à outils, à l’exception de la boîte à outils de Parallel Computing installée - installée sur un système haut de gamme avec SSD -, elle ne peut que terminer dans les 10 secondes. Si nécessaire, vous pouvez modifier les paramètres pour que moins de processus dorment davantage.