Attendez une minute - en moins de dix secondes


69

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.


2
J'ai lu la question plusieurs fois et je ne comprends pas. Pouvez-vous clarifier un peu? Pourquoi "10 secondes" et un délai de "70 secondes"? Comment sont tous ces temps liés?
Luis Mendo

3
Combien de threads pouvons-nous supposer être exécutés en parallèle?
miles

3
Quelle précision est requise pour le temps en sortie?
Edc65

20
Je me demande si cela amènera tous les auteurs de langue golfique à se lancer dans une
course

3
@NoOneIsHere Ah, eh bien, une méthode de veille correctement mise en œuvre ne devrait pas occuper un cœur, le nombre de threads peut donc dépasser le nombre de processeurs (virtuels).
Adám

Réponses:


15

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!


Cela ne fonctionnera pas si exécuté à 23:59:57. Cependant, vous êtes sur la bonne voie ... Alors que vous êtes déjà le plus petit, pouvez-vous jouer au golf 40 autres octets?
Adám

1
@ Adám: non, mais je peux jouer au golf 38 octets. C'est assez évident, je ne sais pas pourquoi je n'y ai pas pensé la première fois.
marinus

Voilà. Seulement 6 autres octets jusqu'à ce que vous obteniez une coche. Les trois choses que vous devez faire sont également assez évidentes, en sauvegardant respectivement 1, 2 et 3 octets.
Adám

Très bien, vous avez trouvé le numéro 1 et le numéro 3. Le numéro 2 ne
joue

Numéro 2: Comme vous n'avez pas besoin d'arguments, faites-en simplement un corps tfn.
Adám

18

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.


Vous pouvez enregistrer deux octets en supprimant l'argument to f()et les deux derniers arguments Thread(en supprimant ainsi 7 caractères) et en utilisant t.append(m()-n)pour éviter d'attribuer une variable locale t(avec 5 caractères de plus que +=.)
Nick Matteo

Et vous pouvez en économiser cinq autres en conservant la somme au lieu d'une liste de fois: initialiser tavec t=[0], remplacer l'ajout par t[0]+=m()-n, et remplacer sum(t)par t[0].
Nick Matteo

Les noms de fil peuvent être omis.
pppery

@ppperry: pas si vous devez utiliser les arguments de position suivants (mais comme je l'ai mentionné dans des commentaires précédents, vous pouvez en fait les écarter.)
Nick Matteo

Économisez trois octets en utilisant import threading as H,time as t; enregistrer deux autres octets en utilisant z=H.Threadet map(z.join,r); économiser deux autres octets en stockant la durée totale sous forme d'attribut (par exemple T.z+=m()-n)
nneonneo

11

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.


Qu'en est-il d'un script forking comme; if [ $1 -lt 9 ];then { ./a $(( $1 + 1 )) &};sleep 7;fiou quelque chose? Cela irait-il à l'encontre des règles ou de quelque chose que je ne comprends pas au sujet de la spécification? [modifier; J'ai raté l'exigence de sortie. Ooh, ça le rend intéressant!]
Dewi Morgan

1
@DewiMorgan Oui, l'exigence de sortie rend la tâche un peu plus difficile. Ce que vous suggérez pourrait ressembler à quelque chose comme:(($1<9))&&$0 $[$1+1]&sleep 7
Digital Trauma

9

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)


1
Bonjour et bienvenue chez PPCG! Ce commentaire @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.ne signifie pas que vous ne devriez pas essayer de jouer au golf avec votre réponse, mais que ce n’est pas grave si elle ne gagne pas. Pouvez-vous s'il vous plaît ajouter une solution de golf?
NoOneIsHere

Je suis désolé, je viens de lire votre édition. Pour jouer au golf, vous pouvez peut-être supprimer les nouvelles lignes et les espaces, ou changer totpour quelque chose comme q.
NoOneIsHere

@NoOneIsHere, merci pour cela, j'avais complètement oublié cette variable! Aussi frappé ensemble m et t.
Rob

1
codebeautify.org/javaviewer - cliquez sur minify
chat le


8

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.


2
function ss(), b=`date +%s`b=$SECONDS, expr $t + $i$[t+i], `cat j`$(<j)et voyez généralement des astuces pour jouer au golf à Bash sur la façon de le réduire à ceci: pastebin.com/DDqUaDug
manatwork

Pour le réduire davantage, écrivez une formule directement dans le fichier j. Je veux dire au lieu d' 5↵5↵5↵…écrire +5+5+5…- chargez le tout directement dans l'évaluation arithmétique et épargnez la deuxième boucle: pastebin.com/LB0BjDMZ
manatwork

Comme la précision minimale a été spécifiée ultérieurement, oubliez la b=`date +%s`b=$SECONDSsuggestion.
Manatwork

1
Comme l' basharithmétique entière, la solution entière doit être réécrite pour utiliser un outil externe de calcul. Typiquement bc: pastebin.com/eYFEVUuz
manatwork le

1
@JuliePelletier Ok, je vais le poster comme ma propre réponse. Néanmoins, je pense que vous pouvez toujours appliquer certaines des techniques de golf à votre réponse sans modifier sensiblement l'approche: pastebin.com/ssYzVs1n (93 bytes)
Digital Trauma

8

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.


8

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


5

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>

1
Je vais dire que c'est bien. :-)
Adám

5

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


2
+1 Très belle et différente approche. Que se passerait-il dans un navigateur mono-thread?
Adám

2
@ Adám Pas de changement de comportement. Il y aurait toujours un délai d'environ 6 secondes. Firefox (un navigateur à un seul thread) produira parfois des choses amusantes comme un temps d’exécution de 59999. <quelque chose>.
Ismael Miguel

4

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

4

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


4

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

Script visuel

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


4

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.


Bienvenue chez PPCG! Nice premier post! Vous pourrez peut-être interroger le PO sur le format de sortie.
Rɪᴋᴇʀ

Pas besoin d'inverser. OP: par n'importe quel moyen et dans n'importe quel format .
Adám

semble que vous pouvez utiliser 7e3au lieu de 7000et utiliser applyau lieu dereduce
cliffroot

3

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


3

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.


1
Je reçois une erreur en { "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 }
exécutant

3

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.


Il est important de noter que cela ne fonctionne que sous Windows et time.clock()se comporte différemment entre les plates-formes Windows et UNIX / Linux .
Mego

3

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

2

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}

2
Wolfram se réserve le droit d'imposer des restrictions de licence pour forger un processus enfant.
Mario Carneiro

2

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)


2
Au lieu de d+=t()-s;if(!c)alert([t()-i,d]), vous pouvez écrire d+=t()-s;c||alert([t()-i,d]), ce qui économisera quelques octets. En outre, si vous supprimez la fonction et réécrire tout, vous pouvez rivaliser avec ma solution à long 92 octets: for(c=8,i=(t=Date.now)(d=0);c--;)setTimeout((c,s)=>{d+=t()-s;c||alert([t()-i,d])},8e3,c,t()). Et oui, celui-ci fait également 92 octets de long.
Ismael Miguel

2

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.


2
Vous êtes à l'intérieur d'un enfant de la classe Thread, ne pouvez-vous pas omettre les Thread.appels à la méthode statique sleep ()? En outre, ce programme ne se terminera-t-il pas en un peu plus de 10 secondes, le disqualifiant?
Réintégrer Monica le

@ABoschman, merci pour votre suggestion, elle est maintenant corrigée, il ne fonctionne plus plus de 10 secondes
user902383

1
En outre, n'oubliez pas que nous avons une base d'utilisateurs très utile pour jouer au golf en java :)
Katenkyo

1
Cela semble sujet aux conditions de concurrence lecture-modification-écriture. Vous n'avez aucune sorte de verrouillage ou quoi que ce soit autour de vous static long t. Je mentionne cela uniquement parce que la spécification indique que "les deux valeurs de temps doivent avoir une précision d'au moins 0,1 seconde".
Poke

1
Vous pouvez supprimer l' long avant set ajouter ,sà static long t,i,s;pour sauvegarder quelques octets.
Kevin Cruijssen

2

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

2

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


Vous pouvez configurer la variable env, mais vous devez compter les octets pour le faire, sauf si le paramètre que vous choisissez est un paramètre commun par défaut.
Adám

@ Adám Merci, c'est ce que je pensais, cela économise 6 ou 7 octets
lundi

2

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

2

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

1

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]

1

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.


Bienvenue dans la communauté !!
Erik the Outgolfer

1

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

1
@ Adám 6 ^ 9> 10 ^ 7 (10 secondes).
Koterpillar

1

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

1

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.


1

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.


L'erreur à propos de best probablement parce que vous avez déjà quelque chose dans votre espace de travail. Je n'ai pas de problèmes sur 2015b en utilisantparfor q=b
Suever

@Suever Oh, j'avais un script nommé bm dans mon dossier MATLAB.
Sanchises
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.