Espera un minuto, en menos de diez segundos

69

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.

Adán
fuente
2
He leído la pregunta varias veces y no la entiendo. ¿Puedes aclarar un poco? ¿Por qué "10 segundos" y un retraso de "70 segundos"? ¿Cómo están relacionados todos esos tiempos?
Luis Mendo
3
¿Cuántos hilos podemos asumir que se ejecutarán en paralelo?
millas
3
¿Qué precisión se requiere para el tiempo de salida?
edc65
20
Me pregunto si esto hará que todos los autores de idiomas de golf participen en una carrera loca para agregar múltiples subprocesos a sus creaciones ...
Adám
3
@NoOneIsHere Ah, bueno, un método de suspensión implementado correctamente no debería ocupar un núcleo, por lo que la cantidad de subprocesos puede exceder la cantidad de procesadores (virtuales).
Adám

Respuestas:

15

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!

marinus
fuente
Esto no funcionará si se ejecuta a las 23:59:57. Sin embargo, estás en el camino correcto ... Si bien ya eres el más bajo, ¿puedes jugar otros 40 bytes?
Adám
1
@ Adám: no, pero puedo jugar al golf 38 bytes. Es bastante obvio, no sé por qué no pensé en esto la primera vez.
marinus
Ahí tienes. Solo otros 6 bytes hasta que obtenga una marca de verificación. Las tres cosas que tiene que hacer también son bastante obvias, ahorrando 1, 2 y 3 bytes respectivamente.
Adám
Muy bien, encontraste el número 1 y el número 3. El número 2 no es realmente golf, sino una alternativa de implementación ...
Adám
Número 2: como no necesita argumentos, simplemente conviértalo en un cuerpo tfn.
Adám
18

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.

Mego
fuente
Puede guardar dos bytes eliminando el argumento f()y los dos últimos argumentos Thread(eliminando así 7 caracteres) y utilizando t.append(m()-n)para evitar asignar una variable local t(utilizando 5 caracteres más que +=.)
Nick Matteo
Y puede ahorrar cinco más manteniendo la suma en lugar de una lista de veces: inicializar tcon t=[0], reemplazar el agregar por t[0]+=m()-ny reemplazar sum(t)por t[0].
Nick Matteo
Los nombres de los hilos pueden omitirse.
pppery
@ppperry: no si necesitas usar los argumentos posicionales posteriores (pero como mencioné en comentarios anteriores, puedes eludirlos)
Nick Matteo
Ahorre tres bytes usando import threading as H,time as t; guardar otros dos bytes usando z=H.Thready map(z.join,r); ahorre otros dos bytes escondiendo el tiempo total como un atributo (por ejemplo T.z+=m()-n)
nneonneo
11

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.

Trauma digital
fuente
¿Qué pasa con un script de bifurcación como; if [ $1 -lt 9 ];then { ./a $(( $1 + 1 )) &};sleep 7;fio algo así? ¿Sería eso contrario a las reglas o algo que no entiendo sobre las especificaciones? [editar; Perdí el requisito de salida. ¡Oh, eso lo hace interesante!]
Dewi Morgan
1
@DewiMorgan Sí, el requisito de salida lo hace un poco más difícil. Lo que usted sugiere podría convertirse en algo como(($1<9))&&$0 $[$1+1]&sleep 7
Trauma digital
9

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)

Robar
fuente
1
Hola y bienvenidos a PPCG! Este comentario @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.no significa que no debas intentar descifrar tu respuesta, sino que está bien si no gana. ¿Puedes por favor agregar una solución de golf?
NoOneIsHere
Lo siento, acabo de leer tu edición. Para jugar al golf, tal vez podría eliminar nuevas líneas y espacios, o cambiar tota algo así q.
NoOneIsHere
@NoOneIsHere, gracias por eso, ¡pasé por alto esa variable por completo! También golpearon juntos myt.
Rob
1
codebeautify.org/javaviewer - haga clic en minify
cat
8

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.

Julie Pelletier
fuente
2
function ss(), b=`date +%s`b=$SECONDS, expr $t + $i$[t+i], `cat j`$(<j)y, en general, vea Consejos para jugar golf en Bash sobre cómo reducirlo a esto: pastebin.com/DDqUaDug
manatwork
Para reducirlo más, mejor escriba directamente una fórmula en el archivo j. Me refiero a en lugar de 5↵5↵5↵…escribir +5+5+5…, luego cargarlo todo directamente en la evaluación aritmética y ahorrar el segundo bucle: pastebin.com/LB0BjDMZ
manatwork
Como la precisión mínima se especificó más tarde, olvide la sugerencia b=`date +%s`b=$SECONDS.
manatwork
1
Al igual bashque la aritmética de enteros, toda la solución debe reescribirse para usar una herramienta externa para el cálculo. Por lo general bc: pastebin.com/eYFEVUuz
manatwork
1
@JuliePelletier Ok, lo publicaré como mi propia respuesta. Aún así, creo que todavía puede aplicar algunas de las técnicas de golf a su respuesta sin cambiar significativamente el enfoque: pastebin.com/ssYzVs1n (93 bytes)
Trauma digital
8

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.

Neil
fuente
8

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

nneonneo
fuente
5

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>
AdmBorkBork
fuente
1
Diré que está bien. :-)
Adám
5

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

Ismael Miguel
fuente
2
+1 Enfoque muy agradable y diferente. ¿Qué pasaría en un navegador de subproceso único?
Adám
2
@ Adám Sin cambios en el comportamiento. Todavía habría un retraso de alrededor de 6 segundos. Firefox (un navegador de un solo subproceso) a veces genera cosas divertidas como un tiempo de ejecución de 59999. <algo>.
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
histocrat
fuente
4

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

Ismael Miguel
fuente
4

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

Guion visual

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

Scimonster
fuente
4

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.

Chris F
fuente
Bienvenido a PPCG! Bonito primer post! Es posible que pueda preguntarle al OP sobre el formato de salida.
Rɪᴋᴇʀ
No hay necesidad de revertir. OP: por cualquier medio y en cualquier formato .
Adám
parece que puede usar en 7e3lugar de 7000y usar en applylugar dereduce
cliffroot
3

Ó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

desigual
fuente
3

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.

bodqhrohro
fuente
1
Recibo un error cuando ejecuto esto:{ "message": "Uncaught SecurityError: Failed to construct 'Worker': Script at 'data:application/javascript,a%3Dnew%20Date()%3BsetTimeout(()%3D%3EpostMessage(new%20Date()-a)%2C5e3)' cannot be accessed from origin 'null'.", "filename": "http://stacksnippets.net/js", "lineno": 13, "colno": 45 }
DJMcMayhem
3

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.

nneonneo
fuente
Es importante tener en cuenta que esto solo funciona en Windows: se time.clock()comporta de manera diferente entre las plataformas Windows y UNIX / Linux .
Mego
3

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
Teclas de acceso rápido
fuente
2

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}
LegionMammal978
fuente
2
Deje que Wolfram ponga restricciones de licencia para bifurcar un proceso secundario.
Mario Carneiro
2

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)

Andrés
fuente
2
En lugar de d+=t()-s;if(!c)alert([t()-i,d]), puede escribir d+=t()-s;c||alert([t()-i,d]), lo que ahorrará algunos bytes. Además, si se quita la función y volver a escribir todo, puede competir con mi solución a largo 92 bytes: for(c=8,i=(t=Date.now)(d=0);c--;)setTimeout((c,s)=>{d+=t()-s;c||alert([t()-i,d])},8e3,c,t()). Y sí, este también tiene 92 bytes de longitud.
Ismael Miguel
2

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.

usuario902383
fuente
2
Estás dentro de un hijo de la clase Thread, ¿no puedes omitir las Thread.llamadas al método estático sleep ()? Además, ¿este programa no terminará en poco más de 10 segundos, descalificándolo?
Vuelva a instalar a Monica el
@ABoschman gracias por su sugerencia, y ya está solucionado, ya no se ejecuta más de 10 segundos
user902383
1
Además, no olvide que tenemos una gran base de usuarios de consejos para jugar al golf en Java :)
Katenkyo
1
Esto parece susceptible a las condiciones de carrera de lectura-modificación-escritura. No tienes ningún tipo de bloqueo ni nada alrededor static long t. Solo menciono esto porque la especificación dice "Ambos valores de tiempo deben tener una precisión de al menos 0.1 segundos".
Poke
1
Puede eliminar el long antes sy agregar ,sal static long t,i,s;para guardar algunos bytes.
Kevin Cruijssen
2

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);}
bodqhrohro
fuente
2

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

dj0wns
fuente
Puede configurar el env var, pero tendría que contar los bytes para hacerlo, excepto si la configuración que elige es un valor predeterminado común.
Adám
@ Adám Gracias, eso es lo que pensé, ahorra 6 o 7 bytes
dj0wns
2

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)))))
Jason
fuente
2

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
primo
fuente
1

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]
hombre trabajando
fuente
1

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.

Candy Gumdrop
fuente
¡Bienvenido a la comunidad!
Erik the Outgolfer
1

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
Koterpillar
fuente
1
@ Adám 6 ^ 9> 10 ^ 7 (10 segundos).
Koterpillar
1

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
moooeeeep
fuente
1

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.

Gosha U.
fuente
1

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.

Sanchises
fuente
El error bprobablemente se deba a que ya tenía algo en su espacio de trabajo. No tengo problemas con 2015b usandoparfor q=b
Suever
@Suever Oh, hey, tenía un script llamado bm en mi carpeta MATLAB.
Sanchises